Merge commit '9e56306f4d7c15e7667d8ac0b62ae6efb93ba756' into HEAD

1652 files changed, 173348 insertions, 4929 deletions

diff --git a/gcc/BASE-VER b/gcc/BASE-VER
index 02161ca..5cb7d85 100644
--- a/gcc/BASE-VER
+++ b/gcc/BASE-VER
@@ -1 +1 @@
-13.0.0
+13.0.1
diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index e32d115..3a8041b 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,1159 @@
+2023-01-31  Gerald Pfeifer  <gerald@pfeifer.com>
+
+	* doc/include/fdl.texi: Change fsf.org to www.fsf.org.
+
+2023-01-30  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/riscv-protos.h (get_vector_mode): New function.
+	* config/riscv/riscv-v.cc (get_vector_mode): Ditto.
+	* config/riscv/riscv-vector-builtins-bases.cc (enum lst_type): New enum.
+	(class loadstore): Adjust for indexed loads/stores support.
+	(BASE): Ditto.
+	* config/riscv/riscv-vector-builtins-bases.h: New function declare.
+	* config/riscv/riscv-vector-builtins-functions.def (vluxei8): Ditto.
+	(vluxei16): Ditto.
+	(vluxei32): Ditto.
+	(vluxei64): Ditto.
+	(vloxei8): Ditto.
+	(vloxei16): Ditto.
+	(vloxei32): Ditto.
+	(vloxei64): Ditto.
+	(vsuxei8): Ditto.
+	(vsuxei16): Ditto.
+	(vsuxei32): Ditto.
+	(vsuxei64): Ditto.
+	(vsoxei8): Ditto.
+	(vsoxei16): Ditto.
+	(vsoxei32): Ditto.
+	(vsoxei64): Ditto.
+	* config/riscv/riscv-vector-builtins-shapes.cc
+	(struct indexed_loadstore_def): New class.
+	(SHAPE): Ditto.
+	* config/riscv/riscv-vector-builtins-shapes.h: Ditto.
+	* config/riscv/riscv-vector-builtins.cc (required_extensions_p): Adjust
+	for indexed loads/stores support.
+	(check_required_extensions): Ditto.
+	(rvv_arg_type_info::get_base_vector_type): New function.
+	(rvv_arg_type_info::get_tree_type): Ditto.
+	(function_builder::add_unique_function): Adjust for indexed loads/stores
+	support.
+	(function_expander::use_exact_insn): New function.
+	* config/riscv/riscv-vector-builtins.h (enum rvv_base_type): Adjust for
+	indexed loads/stores support.
+	(struct rvv_arg_type_info): Ditto.
+	(function_expander::index_mode): New function.
+	(function_base::apply_tail_policy_p): Ditto.
+	(function_base::apply_mask_policy_p): Ditto.
+	* config/riscv/vector-iterators.md (unspec): New unspec.
+	* config/riscv/vector.md (unspec): Ditto.
+	(@pred_indexed_<order>load<VNX1_QHSD:mode><VNX1_QHSDI:mode>): New
+	pattern.
+	(@pred_indexed_<order>store<VNX1_QHSD:mode><VNX1_QHSDI:mode>): Ditto.
+	(@pred_indexed_<order>load<VNX2_QHSD:mode><VNX2_QHSDI:mode>): Ditto.
+	(@pred_indexed_<order>store<VNX2_QHSD:mode><VNX2_QHSDI:mode>): Ditto.
+	(@pred_indexed_<order>load<VNX4_QHSD:mode><VNX4_QHSDI:mode>): Ditto.
+	(@pred_indexed_<order>store<VNX4_QHSD:mode><VNX4_QHSDI:mode>): Ditto.
+	(@pred_indexed_<order>load<VNX8_QHSD:mode><VNX8_QHSDI:mode>): Ditto.
+	(@pred_indexed_<order>store<VNX8_QHSD:mode><VNX8_QHSDI:mode>): Ditto.
+	(@pred_indexed_<order>load<VNX16_QHS:mode><VNX16_QHSI:mode>): Ditto.
+	(@pred_indexed_<order>store<VNX16_QHS:mode><VNX16_QHSI:mode>): Ditto.
+	(@pred_indexed_<order>load<VNX32_QH:mode><VNX32_QHI:mode>): Ditto.
+	(@pred_indexed_<order>store<VNX32_QH:mode><VNX32_QHI:mode>): Ditto.
+	(@pred_indexed_<order>load<VNX64_Q:mode><VNX64_Q:mode>): Ditto.
+	(@pred_indexed_<order>store<VNX64_Q:mode><VNX64_Q:mode>): Ditto.
+
+2023-01-30  Flavio Cruz  <flaviocruz@gmail.com>
+
+	* config.gcc: Recognize x86_64-*-gnu* targets and include
+	i386/gnu64.h.
+	* config/i386/gnu64.h: Define configuration for new target
+	including ld.so location.
+
+2023-01-30  Philipp Tomsich  <philipp.tomsich@vrull.eu>
+
+	* config/aarch64/aarch64-cores.def (AARCH64_CORE): Update
+	ampere1a to include SM4.
+
+2023-01-30  Andrew Pinski  <apinski@marvell.com>
+
+	PR tree-optimization/108582
+	* tree-ssa-phiopt.cc (match_simplify_replacement): Add check
+	for middlebb to have no phi nodes.
+
+2023-01-30  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/108574
+	* tree-ssa-sccvn.cc (visit_phi): Instead of swapping
+	sameval and def, ignore the equivalence if there's the
+	danger of oscillating between two values.
+
+2023-01-30  Andreas Schwab  <schwab@suse.de>
+
+	* common/config/riscv/riscv-common.cc
+	(riscv_option_optimization_table)
+	[TARGET_DEFAULT_ASYNC_UNWIND_TABLES]: Enable
+	-fasynchronous-unwind-tables and -funwind-tables.
+	* config.gcc (riscv*-*-linux*): Define
+	TARGET_DEFAULT_ASYNC_UNWIND_TABLES.
+
+2023-01-30  YunQiang Su  <yunqiang.su@cipunited.com>
+
+	* Makefile.in (CROSS_SYSTEM_HEADER_DIR): set according the
+	value of includedir.
+
+2023-01-30  Richard Biener  <rguenther@suse.de>
+
+	PR ipa/108511
+	* cgraph.cc (possibly_call_in_translation_unit_p): Relax
+	assert.
+
+2023-01-30  liuhongt  <hongtao.liu@intel.com>
+
+	* config/i386/i386.opt: Change AVX512FP16 to AVX512-FP16.
+	* doc/invoke.texi: Ditto.
+
+2023-01-29  Jan Hubicka  <hubicka@ucw.cz>
+
+	* ipa-utils.cc: Include calls.h, cfgloop.h and cfganal.h
+	(stmt_may_terminate_function_p): If assuming return or EH
+	volatile asm is safe.
+	(find_always_executed_bbs): Fix handling of terminating BBS and
+	infinite loops; add debug output.
+	* tree-ssa-alias.cc (stmt_kills_ref_p): Fix debug output
+
+2023-01-28  Philipp Tomsich  <philipp.tomsich@vrull.eu>
+
+	* config/aarch64/aarch64.cc (aarch64_uxt_size): fix an
+	off-by-one in checking the permissible shift-amount.
+
+2023-01-28  Gerald Pfeifer  <gerald@pfeifer.com>
+
+	* doc/extend.texi (Named Address Spaces): Update link to the
+	AVR-Libc manual.
+
+2023-01-28  Gerald Pfeifer  <gerald@pfeifer.com>
+
+	* doc/standards.texi (Standards): Fix markup.
+
+2023-01-28  Gerald Pfeifer  <gerald@pfeifer.com>
+
+	* doc/standards.texi (Standards): Update link to Objective-C book.
+
+2023-01-28  Gerald Pfeifer  <gerald@pfeifer.com>
+
+	* doc/invoke.texi (Instrumentation Options): Update reference to
+	AddressSanitizer.
+
+2023-01-28  Gerald Pfeifer  <gerald@pfeifer.com>
+
+	* doc/standards.texi: Update Go1 link.
+
+2023-01-28  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/predicates.md (pmode_reg_or_0_operand): New predicate.
+	* config/riscv/riscv-vector-builtins-bases.cc (class loadstore):
+	Support vlse/vsse.
+	(BASE): Ditto.
+	* config/riscv/riscv-vector-builtins-bases.h: Ditto.
+	* config/riscv/riscv-vector-builtins-functions.def (vlse): New class.
+	(vsse): New class.
+	* config/riscv/riscv-vector-builtins.cc
+	(function_expander::use_contiguous_load_insn): Support vlse/vsse.
+	* config/riscv/vector.md (@pred_strided_load<mode>): New md pattern.
+	(@pred_strided_store<mode>): Ditto.
+
+2023-01-28  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/vector.md (tail_policy_op_idx): Remove.
+	(mask_policy_op_idx): Remove.
+	(avl_type_op_idx): Remove.
+
+2023-01-27  Richard Sandiford  <richard.sandiford@arm.com>
+
+	PR tree-optimization/96373
+	* tree.h (sign_mask_for): Declare.
+	* tree.cc (sign_mask_for): New function.
+	(signed_or_unsigned_type_for): For vector types, try to use the
+	related_int_vector_mode.
+	* genmatch.cc (commutative_op): Handle conditional internal functions.
+	* match.pd: Fold an IFN_COND_MUL+copysign into an IFN_COND_XOR+and.
+
+2023-01-27  Richard Sandiford  <richard.sandiford@arm.com>
+
+	* tree-vectorizer.cc (vector_costs::compare_inside_loop_cost):
+	Use the likely minimum VF when bounding the denominators to
+	the estimated number of iterations.
+
+2023-01-27  Richard Biener  <rguenther@suse.de>
+
+	PR target/55522
+	* doc/invoke.texi (-shared): Clarify effect on -ffast-math
+	and -Ofast FP environment side-effects.
+
+2023-01-27  Richard Biener  <rguenther@suse.de>
+
+	PR target/55522
+	* config/mips/gnu-user.h (GNU_USER_TARGET_MATHFILE_SPEC):
+	Don't add crtfastmath.o for -shared.
+
+2023-01-27  Richard Biener  <rguenther@suse.de>
+
+	PR target/55522
+	* config/ia64/linux.h (ENDFILE_SPEC): Don't add crtfastmath.o
+	for -shared.
+
+2023-01-27  Richard Biener  <rguenther@suse.de>
+
+	PR target/55522
+	* config/alpha/linux.h (ENDFILE_SPEC): Don't add
+	crtfastmath.o for -shared.
+
+2023-01-27  Andrew MacLeod  <amacleod@redhat.com>
+
+	PR tree-optimization/108306
+	* range-op.cc (operator_lshift::fold_range): Return [0, 0] not
+	varying for shifts that are always out of void range.
+	(operator_rshift::fold_range): Return [0, 0] not
+	varying for shifts that are always out of void range.
+
+2023-01-27  Andrew MacLeod  <amacleod@redhat.com>
+
+	PR tree-optimization/108447
+	* gimple-range-fold.cc (old_using_range::relation_fold_and_or):
+	Do not attempt to fold HONOR_NAN types.
+
+2023-01-27  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/riscv-vector-builtins-shapes.cc (struct loadstore_def):
+	Remove _m suffix for "vop_m" C++ overloaded API name.
+
+2023-01-27  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/riscv-vector-builtins-bases.cc (BASE): Add vlm/vsm support.
+	* config/riscv/riscv-vector-builtins-bases.h: Ditto.
+	* config/riscv/riscv-vector-builtins-functions.def (vlm): New define.
+	(vsm): Ditto.
+	* config/riscv/riscv-vector-builtins-shapes.cc (struct loadstore_def): Add vlm/vsm support.
+	* config/riscv/riscv-vector-builtins-types.def (DEF_RVV_B_OPS): Ditto.
+	(vbool64_t): Ditto.
+	(vbool32_t): Ditto.
+	(vbool16_t): Ditto.
+	(vbool8_t): Ditto.
+	(vbool4_t): Ditto.
+	(vbool2_t): Ditto.
+	(vbool1_t): Ditto.
+	* config/riscv/riscv-vector-builtins.cc (DEF_RVV_B_OPS): Ditto.
+	(rvv_arg_type_info::get_tree_type): Ditto.
+	(function_expander::use_contiguous_load_insn): Ditto.
+	* config/riscv/vector.md (@pred_store<mode>): Ditto.
+
+2023-01-27  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/riscv-vsetvl.cc (vsetvl_insn_p): Add condition to avoid ICE.
+	(vsetvl_discard_result_insn_p): New function.
+	(reg_killed_by_bb_p): rename to find_reg_killed_by.
+	(find_reg_killed_by): New name.
+	(get_vl): allow it to be called by more functions.
+	(has_vsetvl_killed_avl_p): Add condition.
+	(get_avl): allow it to be called by more functions.
+	(insn_should_be_added_p): New function.
+	(get_all_nonphi_defs): Refine function.
+	(get_all_sets): Ditto.
+	(get_same_bb_set): New function.
+	(any_insn_in_bb_p): Ditto.
+	(any_set_in_bb_p): Ditto.
+	(get_vl_vtype_info): Add VLMAX forward optimization.
+	(source_equal_p): Fix issues.
+	(extract_single_source): Refine.
+	(avl_info::multiple_source_equal_p): New function.
+	(avl_info::operator==): Adjust for final version.
+	(vl_vtype_info::operator==): Ditto.
+	(vl_vtype_info::same_avl_p): Ditto.
+	(vector_insn_info::parse_insn): Ditto.
+	(vector_insn_info::available_p): New function.
+	(vector_insn_info::merge): Adjust for final version.
+	(vector_insn_info::dump): Add hard_empty.
+	(pass_vsetvl::hard_empty_block_p): New function.
+	(pass_vsetvl::backward_demand_fusion): Adjust for final version.
+	(pass_vsetvl::forward_demand_fusion): Ditto.
+	(pass_vsetvl::demand_fusion): Ditto.
+	(pass_vsetvl::cleanup_illegal_dirty_blocks): New function.
+	(pass_vsetvl::compute_local_properties): Adjust for final version.
+	(pass_vsetvl::can_refine_vsetvl_p): Ditto.
+	(pass_vsetvl::refine_vsetvls): Ditto.
+	(pass_vsetvl::commit_vsetvls): Ditto.
+	(pass_vsetvl::propagate_avl): New function.
+	(pass_vsetvl::lazy_vsetvl): Adjust for new version.
+	* config/riscv/riscv-vsetvl.h (enum def_type): New enum.
+
+2023-01-27  Jakub Jelinek  <jakub@redhat.com>
+
+	PR other/108560
+	* doc/extend.texi: Fix up return type of __builtin_va_arg_pack_len
+	from size_t to int.
+
+2023-01-27  Jakub Jelinek  <jakub@redhat.com>
+
+	PR ipa/106061
+	* cgraph.cc (cgraph_edge::verify_corresponds_to_fndecl): Allow
+	redirection of calls to __builtin_trap in addition to redirection
+	to __builtin_unreachable.
+
+2023-01-27  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/riscv-vsetvl.cc (before_p): Fix bug.
+
+2023-01-27  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/riscv-vsetvl.cc (gen_vsetvl_pat): Refine function args.
+	(emit_vsetvl_insn): Ditto.
+
+2023-01-27  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/vector.md: Fix constraints.
+
+2023-01-27  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/vector-iterators.md: Add TARGET_MIN_VLEN > 32 predicates.
+
+2023-01-27  Patrick Palka  <ppalka@redhat.com>
+	    Jakub Jelinek  <jakub@redhat.com>
+
+	* tree-core.h (tree_code_type, tree_code_length): For
+	C++17 and later, add inline keyword, otherwise don't define
+	the arrays, but declare extern arrays.
+	* tree.cc (tree_code_type, tree_code_length): Define these
+	arrays for C++14 and older.
+
+2023-01-27  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/riscv-vsetvl.h: Change it into public.
+
+2023-01-27  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/riscv-passes.def (INSERT_PASS_BEFORE): Reorder VSETVL
+	pass.
+
+2023-01-27  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/riscv-vsetvl.cc (pass_vsetvl::execute): Always call split_all_insns.
+
+2023-01-27  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/vector.md: Fix incorrect attributes.
+
+2023-01-27  Richard Biener  <rguenther@suse.de>
+
+	PR target/55522
+	* config/loongarch/gnu-user.h (GNU_USER_TARGET_MATHFILE_SPEC):
+	Don't add crtfastmath.o for -shared.
+
+2023-01-27  Alexandre Oliva  <oliva@gnu.org>
+
+	* doc/options.texi (option, RejectNegative): Mention that
+	-g-started options are also implicitly negatable.
+
+2023-01-26  Kito Cheng  <kito.cheng@sifive.com>
+
+	* config/riscv/riscv-vector-builtins.cc (register_builtin_types):
+	Use get_typenode_from_name to get fixed-width integer type
+	nodes.
+	* config/riscv/riscv-vector-builtins.def: Update define with
+	fixed-width integer type nodes.
+
+2023-01-26  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/riscv-vsetvl.cc (same_bb_and_before_p): Remove it.
+	(real_insn_and_same_bb_p): New function.
+	(same_bb_and_after_or_equal_p): Remove it.
+	(before_p): New function.
+	(reg_killed_by_bb_p): Ditto.
+	(has_vsetvl_killed_avl_p): Ditto.
+	(get_vl): Move location so that we can call it.
+	(anticipatable_occurrence_p): Fix issue of AVL=REG support.
+	(available_occurrence_p): Ditto.
+	(dominate_probability_p): Remove it.
+	(can_backward_propagate_p): Remove it.
+	(get_all_nonphi_defs): New function.
+	(get_all_predecessors): Ditto.
+	(any_insn_in_bb_p): Ditto.
+	(insert_vsetvl): Adjust AVL REG.
+	(source_equal_p): New function.
+	(extract_single_source): Ditto.
+	(avl_info::single_source_equal_p): Ditto.
+	(avl_info::operator==): Adjust for AVL=REG.
+	(vl_vtype_info::same_avl_p): Ditto.
+	(vector_insn_info::set_demand_info): Remove it.
+	(vector_insn_info::compatible_p): Adjust for AVL=REG.
+	(vector_insn_info::compatible_avl_p): New function.
+	(vector_insn_info::merge): Adjust AVL=REG.
+	(vector_insn_info::dump): Ditto.
+	(pass_vsetvl::merge_successors): Remove it.
+	(enum fusion_type): New enum.
+	(pass_vsetvl::get_backward_fusion_type): New function.
+	(pass_vsetvl::backward_demand_fusion): Adjust for AVL=REG.
+	(pass_vsetvl::forward_demand_fusion): Ditto.
+	(pass_vsetvl::demand_fusion): Ditto.
+	(pass_vsetvl::prune_expressions): Ditto.
+	(pass_vsetvl::compute_local_properties): Ditto.
+	(pass_vsetvl::cleanup_vsetvls): Ditto.
+	(pass_vsetvl::commit_vsetvls): Ditto.
+	(pass_vsetvl::init): Ditto.
+	* config/riscv/riscv-vsetvl.h (enum fusion_type): New enum.
+	(enum merge_type): New enum.
+
+2023-01-26  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/riscv-vsetvl.cc
+	(vector_infos_manager::vector_infos_manager): Add probability.
+	(vector_infos_manager::dump): Ditto.
+	(pass_vsetvl::compute_probabilities): Ditto.
+	* config/riscv/riscv-vsetvl.h (struct vector_block_info): Ditto.
+
+2023-01-26  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/riscv-vsetvl.cc (vector_insn_info::operator==): Remove dirty_pat.
+	(vector_insn_info::merge): Ditto.
+	(vector_insn_info::dump): Ditto.
+	(pass_vsetvl::merge_successors): Ditto.
+	(pass_vsetvl::backward_demand_fusion): Ditto.
+	(pass_vsetvl::forward_demand_fusion): Ditto.
+	(pass_vsetvl::commit_vsetvls): Ditto.
+	* config/riscv/riscv-vsetvl.h: Ditto.
+
+2023-01-26  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/riscv-vsetvl.cc (add_label_notes): Rename insn to
+	rinsn.
+
+2023-01-26  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/riscv-vsetvl.cc (pass_vsetvl::backward_demand_fusion): Refine codes.
+
+2023-01-26  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/riscv-vsetvl.cc (pass_vsetvl::forward_demand_fusion):
+	Add pre-check for redundant flow.
+
+2023-01-26  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/riscv-vsetvl.cc (vector_infos_manager::create_bitmap_vectors): New function.
+	(vector_infos_manager::free_bitmap_vectors): Ditto.
+	(pass_vsetvl::pre_vsetvl): Adjust codes.
+	* config/riscv/riscv-vsetvl.h: New function declaration.
+
+2023-01-26  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/riscv-vsetvl.cc (can_backward_propagate_p): Fix for null iter_bb.
+	(vector_insn_info::set_demand_info): New function.
+	(pass_vsetvl::emit_local_forward_vsetvls): Adjust for refinement of Phase 3.
+	(pass_vsetvl::merge_successors): Ditto.
+	(pass_vsetvl::compute_global_backward_infos): Ditto.
+	(pass_vsetvl::backward_demand_fusion): Ditto.
+	(pass_vsetvl::forward_demand_fusion): Ditto.
+	(pass_vsetvl::demand_fusion): New function.
+	(pass_vsetvl::lazy_vsetvl): Adjust for refinement of phase 3.
+	* config/riscv/riscv-vsetvl.h: New function declaration.
+
+2023-01-26  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/riscv-vsetvl.cc (vector_insn_info::operator>=): Fix available condition.
+
+2023-01-26  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/riscv-vsetvl.cc (change_vsetvl_insn): New function.
+	(pass_vsetvl::compute_global_backward_infos): Simplify codes.
+
+2023-01-26  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/riscv-vsetvl.cc (loop_basic_block_p): Adjust function.
+	(backward_propagate_worthwhile_p): Fix non-worthwhile.
+
+2023-01-26  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/riscv-vsetvl.cc (change_insn): Adjust in_group in validate_change.
+
+2023-01-26  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/riscv-vsetvl.cc (vector_infos_manager::all_same_avl_p): New function.
+	(pass_vsetvl::can_refine_vsetvl_p): Add AVL check.
+	(pass_vsetvl::commit_vsetvls): Ditto.
+	* config/riscv/riscv-vsetvl.h: New function declaration.
+
+2023-01-26  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/vector.md:
+
+2023-01-26  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/riscv-vector-builtins-bases.cc (class loadstore): use
+	pred_store for vse.
+	* config/riscv/riscv-vector-builtins.cc
+	(function_expander::add_mem_operand): Refine function.
+	(function_expander::use_contiguous_load_insn): Adjust new
+	implementation.
+	(function_expander::use_contiguous_store_insn): Ditto.
+	* config/riscv/riscv-vector-builtins.h: Refine function.
+	* config/riscv/vector.md (@pred_store<mode>): New pattern.
+
+2023-01-26  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/riscv-vector-builtins.cc: Change to scalar pointer.
+
+2023-01-26  Marek Polacek  <polacek@redhat.com>
+
+	PR middle-end/108543
+	* opts.cc (parse_sanitizer_options): Don't always clear SANITIZE_ADDRESS
+	if it was previously set.
+
+2023-01-26  Jakub Jelinek  <jakub@redhat.com>
+
+	PR tree-optimization/108540
+	* range-op-float.cc (foperator_equal::fold_range): If both op1 and op2
+	are singletons, use range_true even if op1 != op2
+	when one range is [-0.0, -0.0] and another [0.0, 0.0].  Similarly,
+	even if intersection of the ranges is empty and one has
+	zero low bound and another zero high bound, use range_true_and_false
+	rather than range_false.
+	(foperator_not_equal::fold_range): If both op1 and op2
+	are singletons, use range_false even if op1 != op2
+	when one range is [-0.0, -0.0] and another [0.0, 0.0].  Similarly,
+	even if intersection of the ranges is empty and one has
+	zero low bound and another zero high bound, use range_true_and_false
+	rather than range_true.
+
+2023-01-26  Jakub Jelinek  <jakub@redhat.com>
+
+	* value-relation.cc (kind_string): Add const.
+	(rr_negate_table, rr_swap_table, rr_intersect_table,
+	rr_union_table, rr_transitive_table): Add static const, change
+	element type from relation_kind to unsigned char.
+	(relation_negate, relation_swap, relation_intersect, relation_union,
+	relation_transitive): Cast rr_*_table element to relation_kind.
+	(relation_to_code): Add static const.
+	(relation_tests): Assert VREL_LAST is smaller than UCHAR_MAX.
+
+2023-01-26  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/108547
+	* gimple-predicate-analysis.cc (value_sat_pred_p):
+	Use widest_int.
+
+2023-01-26  Siddhesh Poyarekar  <siddhesh@gotplt.org>
+
+	PR tree-optimization/108522
+	* tree-object-size.cc (compute_object_offset): Make EXPR
+	argument non-const.  Call component_ref_field_offset.
+
+2023-01-26  Kyrylo Tkachov  <kyrylo.tkachov@arm.com>
+
+	* config/aarch64/aarch64-option-extensions.def (cssc): Specify
+	FEATURE_STRING field.
+
+2023-01-26  Gerald Pfeifer  <gerald@pfeifer.com>
+
+	* doc/sourcebuild.texi: Refer to projects as GCC and GDB.
+
+2023-01-25  Iain Sandoe  <iain@sandoe.co.uk>
+
+	PR modula2/102343
+	PR modula2/108182
+	* gcc.cc: Provide default specs for Modula-2 so that when the
+	language is not built-in better diagnostics are emitted for
+	attempts to use .mod or .m2i file extensions.
+
+2023-01-25  Andrea Corallo  <andrea.corallo@arm.com>
+
+	* config/arm/mve.md (mve_vqnegq_s<mode>): Fix spacing.
+
+2023-01-25  Andrea Corallo  <andrea.corallo@arm.com>
+
+	* config/arm/mve.md (mve_vqabsq_s<mode>): Fix spacing.
+
+2023-01-25  Andrea Corallo  <andrea.corallo@arm.com>
+
+	* config/arm/mve.md (mve_vnegq_f<mode>, mve_vnegq_s<mode>):
+	Fix spacing.
+
+2023-01-25  Andrea Corallo  <andrea.corallo@arm.com>
+
+	* config/arm/mve.md (@mve_vclzq_s<mode>): Fix spacing.
+
+2023-01-25  Andrea Corallo  <andrea.corallo@arm.com>
+
+	* config/arm/mve.md (mve_vclsq_s<mode>): Fix spacing.
+
+2023-01-25  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/108523
+	* tree-ssa-sccvn.cc (visit_phi): Avoid using the exclusive
+	backedge value for the result when using predication to
+	prove equivalence.
+
+2023-01-25  Richard Biener  <rguenther@suse.de>
+
+	* doc/lto.texi (Command line options): Reword and update reference
+	to removed lto_read_all_file_options.
+
+2023-01-25  Richard Sandiford  <richard.sandiford@arm.com>
+
+	* config/aarch64/aarch64.md (umax<mode>3): Separate the CNT and CSSC
+	tests.
+
+2023-01-25  Gerald Pfeifer  <gerald@pfeifer.com>
+
+	* doc/contrib.texi: Add Jose E. Marchesi.
+
+2023-01-25  Jakub Jelinek  <jakub@redhat.com>
+
+	PR tree-optimization/108498
+	* gimple-ssa-store-merging.cc (class store_operand_info):
+	End coment with full stop rather than comma.
+	(split_group): Likewise.
+	(merged_store_group::apply_stores): Clear string_concatenation if
+	start or end aren't on a byte boundary.
+
+2023-01-25  Siddhesh Poyarekar  <siddhesh@gotplt.org>
+	    Jakub Jelinek  <jakub@redhat.com>
+
+	PR tree-optimization/108522
+	* tree-object-size.cc (compute_object_offset): Use
+	TREE_OPERAND(ref, 2) for COMPONENT_REF when available.
+
+2023-01-24  Takayuki 'January June' Suwa  <jjsuwa_sys3175@yahoo.co.jp>
+
+	* config/xtensa/xtensa.md:
+	Fix exit from loops detecting references before overwriting in the
+	split pattern.
+
+2023-01-24  Vladimir N. Makarov  <vmakarov@redhat.com>
+
+	* lra-constraints.cc (get_hard_regno): Remove final_p arg.  Always
+	do elimination but only for hard register.
+	(operands_match_p, uses_hard_regs_p, process_alt_operands): Adjust
+	calls of get_hard_regno.
+
+2023-01-24  Stefan Schulze Frielinghaus  <stefansf@linux.ibm.com>
+
+	* config/s390/s390-d.cc (s390_d_target_versions): Fix detection
+	of CPU version.
+
+2023-01-24  Andre Vieira  <andre.simoesdiasvieira@arm.com>
+
+	PR target/108177
+	* config/arm/mve.md (mve_vstrbq_p_<supf><mode>, mve_vstrhq_p_fv8hf,
+	mve_vstrhq_p_<supf><mode>, mve_vstrwq_p_<supf>v4si): Add memory operand
+	as input operand.
+
+2023-01-24  Xianmiao Qu  <cooper.qu@linux.alibaba.com>
+
+	* config.gcc(csky-*-linux*): Define CSKY_ENABLE_MULTILIB
+	and only include 'csky/t-csky-linux' when enable multilib.
+	* config/csky/csky-linux-elf.h(SYSROOT_SUFFIX_SPEC): Don't
+	define it when disable multilib.
+
+2023-01-24  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/108500
+	* dominance.h (calculate_dominance_info): Add parameter
+	to indicate fast-query compute, defaulted to true.
+	* dominance.cc (calculate_dominance_info): Honor
+	fast-query compute parameter.
+	* tree-cfgcleanup.cc (cleanup_tree_cfg_noloop): Do
+	not compute the dominator fast-query DFS numbers.
+
+2023-01-24  Eric Biggers  <ebiggers@google.com>
+
+	PR bootstrap/90543
+	* optc-save-gen.awk: Fix copy-and-paste error.
+
+2023-01-24  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/108474
+	* cgraphbuild.cc: Include gimplify.h.
+	(record_reference): Replace VAR_DECLs with DECL_HAS_VALUE_EXPR_P with
+	their corresponding DECL_VALUE_EXPR expressions after unsharing.
+
+2023-01-24  Srinath Parvathaneni  <srinath.parvathaneni@arm.com>
+
+	PR target/108505
+	* config.gcc (tm_file): Move the variable out of loop.
+
+2023-01-24  Lulu Cheng  <chenglulu@loongson.cn>
+	    Yang Yujie  <yangyujie@loongson.cn>
+
+	PR target/107731
+	* config/loongarch/loongarch.cc (loongarch_classify_address):
+	Add precessint for CONST_INT.
+	(loongarch_print_operand_reloc): Operand modifier 'c' is supported.
+	(loongarch_print_operand): Increase the processing of '%c'.
+	* doc/extend.texi: Adds documents for LoongArch operand modifiers.
+	And port the public operand modifiers information to this document.
+
+2023-01-23  Srinath Parvathaneni  <srinath.parvathaneni@arm.com>
+
+	* doc/invoke.texi (-mbranch-protection): Update documentation.
+
+2023-01-23  Richard Biener  <rguenther@suse.de>
+
+	PR target/55522
+	* config/sparc/freebsd.h (ENDFILE_SPEC): Don't add crtfastmath.o
+	for -shared.
+	* config/sparc/linux.h (ENDFILE_SPEC): Likewise.
+	* config/sparc/linux64.h (ENDFILE_SPEC): Likewise.
+	* config/sparc/sp-elf.h (ENDFILE_SPEC): Likewise.
+	* config/sparc/sp64-elf.h (ENDFILE_SPEC): Likewise.
+
+2023-01-23  Srinath Parvathaneni  <srinath.parvathaneni@arm.com>
+
+	* config/arm/aout.h (ra_auth_code): Add entry in enum.
+	* config/arm/arm.cc (emit_multi_reg_push): Add RA_AUTH_CODE register
+	to dwarf frame expression.
+	(arm_emit_multi_reg_pop): Restore RA_AUTH_CODE register.
+	(arm_expand_prologue): Update frame related information and reg notes
+	for pac/pacbit insn.
+	(arm_regno_class): Check for pac pseudo reigster.
+	(arm_dbx_register_number): Assign ra_auth_code register number in dwarf.
+	(arm_init_machine_status): Set pacspval_needed to zero.
+	(arm_debugger_regno): Check for PAC register.
+	(arm_unwind_emit_sequence): Print .save directive with ra_auth_code
+	register.
+	(arm_unwind_emit_set): Add entry for IP_REGNUM in switch case.
+	(arm_unwind_emit): Update REG_CFA_REGISTER case._
+	* config/arm/arm.h (FIRST_PSEUDO_REGISTER): Modify.
+	(DWARF_PAC_REGNUM): Define.
+	(IS_PAC_REGNUM): Likewise.
+	(enum reg_class): Add PAC_REG entry.
+	(machine_function): Add pacbti_needed state to structure.
+	* config/arm/arm.md (RA_AUTH_CODE): Define.
+
+2023-01-23  Srinath Parvathaneni  <srinath.parvathaneni@arm.com>
+
+	* config.gcc ($tm_file): Update variable.
+	* config/arm/arm-mlib.h: Create new header file.
+	* config/arm/t-rmprofile (MULTI_ARCH_DIRS_RM): Rename mbranch-protection
+	multilib arch directory.
+	(MULTILIB_REUSE): Add multilib reuse rules.
+	(MULTILIB_MATCHES): Add multilib match rules.
+
+2023-01-23  Srinath Parvathaneni  <srinath.parvathaneni@arm.com>
+
+	* config/arm/arm-cpus.in (cortex-m85): Define new CPU.
+	* config/arm/arm-tables.opt: Regenerate.
+	* config/arm/arm-tune.md: Likewise.
+	* doc/invoke.texi (Arm Options): Document -mcpu=cortex-m85.
+	* (-mfix-cmse-cve-2021-35465): Likewise.
+
+2023-01-23  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/108482
+	* tree-vect-generic.cc (expand_vector_operations): Fold remaining
+	.LOOP_DIST_ALIAS calls.
+
+2023-01-23  Andrea Corallo  <andrea.corallo@arm.com>
+
+	* config.gcc (arm*-*-*): Add 'aarch-bti-insert.o' object.
+	* config/arm/arm-protos.h: Update.
+	* config/arm/aarch-common-protos.h: Declare
+	'aarch_bti_arch_check'.
+	* config/arm/arm.cc (aarch_bti_enabled) Update.
+	(aarch_bti_j_insn_p, aarch_pac_insn_p, aarch_gen_bti_c)
+	(aarch_gen_bti_j, aarch_bti_arch_check): New functions.
+	* config/arm/arm.md (bti_nop): New insn.
+	* config/arm/t-arm (PASSES_EXTRA): Add 'arm-passes.def'.
+	(aarch-bti-insert.o): New target.
+	* config/arm/unspecs.md (VUNSPEC_BTI_NOP): New unspec.
+	* config/arm/aarch-bti-insert.cc (rest_of_insert_bti): Verify arch
+	compatibility.
+	(gate): Make use of 'aarch_bti_arch_check'.
+	* config/arm/arm-passes.def: New file.
+	* config/aarch64/aarch64.cc (aarch_bti_arch_check): New function.
+
+2023-01-23  Andrea Corallo  <andrea.corallo@arm.com>
+
+	* config.gcc (aarch64*-*-*): Rename 'aarch64-bti-insert.o' into
+	'aarch-bti-insert.o'.
+	* config/aarch64/aarch64-protos.h: Remove 'aarch64_bti_enabled'
+	proto.
+	* config/aarch64/aarch64.cc (aarch_bti_enabled): Rename.
+	(aarch_bti_j_insn_p, aarch_pac_insn_p): New functions.
+	(aarch64_output_mi_thunk)
+	(aarch64_print_patchable_function_entry)
+	(aarch64_file_end_indicate_exec_stack): Update renamed function
+	calls to renamed functions.
+	* config/aarch64/aarch64-c.cc (aarch64_update_cpp_builtins): Likewise.
+	* config/aarch64/t-aarch64 (aarch-bti-insert.o): Update
+	target.
+	* config/aarch64/aarch64-bti-insert.cc: Delete.
+	* config/arm/aarch-bti-insert.cc: New file including and
+	generalizing code from aarch64-bti-insert.cc.
+	* config/arm/aarch-common-protos.h: Update.
+
+2023-01-23  Andrea Corallo  <andrea.corallo@arm.com>
+
+	* config/arm/arm.h (arm_arch8m_main): Declare it.
+	* config/arm/arm-protos.h (arm_current_function_pac_enabled_p):
+	Declare it.
+	* config/arm/arm.cc (arm_arch8m_main): Define it.
+	(arm_option_reconfigure_globals): Set arm_arch8m_main.
+	(arm_compute_frame_layout, arm_expand_prologue)
+	(thumb2_expand_return, arm_expand_epilogue)
+	(arm_conditional_register_usage): Update for pac codegen.
+	(arm_current_function_pac_enabled_p): New function.
+	(aarch_bti_enabled) New function.
+	(use_return_insn): Return zero when pac is enabled.
+	* config/arm/arm.md (pac_ip_lr_sp, pacbti_ip_lr_sp, aut_ip_lr_sp):
+	Add new patterns.
+	* config/arm/unspecs.md (UNSPEC_PAC_NOP)
+	(VUNSPEC_PACBTI_NOP, VUNSPEC_AUT_NOP): Add unspecs.
+
+2023-01-23  Andrea Corallo  <andrea.corallo@arm.com>
+
+	* config/arm/t-rmprofile: Add multilib rules for march +pacbti and
+	mbranch-protection.
+
+2023-01-23  Andrea Corallo  <andrea.corallo@arm.com>
+	    Tejas Belagod   <tbelagod@arm.com>
+
+	* config/arm/arm.cc (arm_file_start): Emit EABI attributes for
+	Tag_PAC_extension, Tag_BTI_extension, TAG_BTI_use, TAG_PACRET_use.
+
+2023-01-23  Andrea Corallo  <andrea.corallo@arm.com>
+	    Tejas Belagod   <tbelagod@arm.com>
+	    Srinath Parvathaneni  <srinath.parvathaneni@arm.com>
+
+	* ginclude/unwind-arm-common.h (_Unwind_VRS_RegClass): Introduce
+	new pseudo register class _UVRSC_PAC.
+
+2023-01-23  Andrea Corallo  <andrea.corallo@arm.com>
+	    Tejas Belagod   <tbelagod@arm.com>
+
+	* config/arm/arm-c.cc (arm_cpu_builtins): Define
+	__ARM_FEATURE_BTI_DEFAULT, __ARM_FEATURE_PAC_DEFAULT,
+	__ARM_FEATURE_PAUTH and __ARM_FEATURE_BTI.
+
+2023-01-23  Andrea Corallo  <andrea.corallo@arm.com>
+	    Tejas Belagod   <tbelagod@arm.com>
+
+	* doc/sourcebuild.texi: Document arm_pacbti_hw.
+
+2023-01-23  Andrea Corallo  <andrea.corallo@arm.com>
+	    Tejas Belagod   <tbelagod@arm.com>
+	    Richard Earnshaw  <Richard.Earnshaw@arm.com>
+
+	* config/arm/arm.cc (arm_configure_build_target): Parse and validate
+	-mbranch-protection option and initialize appropriate data structures.
+	* config/arm/arm.opt (-mbranch-protection): New option.
+	* doc/invoke.texi (Arm Options): Document it.
+
+2023-01-23  Andrea Corallo  <andrea.corallo@arm.com>
+	    Tejas Belagod   <tbelagod@arm.com>
+
+	* config/arm/arm.h (TARGET_HAVE_PACBTI): New macro.
+	* config/arm/arm-cpus.in (pacbti): New feature.
+	* doc/invoke.texi (Arm Options): Document it.
+
+2023-01-23  Andrea Corallo  <andrea.corallo@arm.com>
+	    Tejas Belagod   <tbelagod@arm.com>
+
+	* common/config/aarch64/aarch64-common.cc: Include aarch-common.h.
+	(all_architectures): Fix comment.
+	(aarch64_parse_extension): Rename return type, enum value names.
+	* config/aarch64/aarch64-c.cc (aarch64_update_cpp_builtins): Rename
+	factored out aarch_ra_sign_scope and aarch_ra_sign_key variables.
+	Also rename corresponding enum values.
+	* config/aarch64/aarch64-opts.h (aarch64_function_type): Factor
+	out aarch64_function_type and move it to common code as
+	aarch_function_type in aarch-common.h.
+	* config/aarch64/aarch64-protos.h: Include common types header,
+	move out types aarch64_parse_opt_result and aarch64_key_type to
+	aarch-common.h
+	* config/aarch64/aarch64.cc: Move mbranch-protection parsing types
+	and functions out into aarch-common.h and aarch-common.cc.  Fix up
+	all the name changes resulting from the move.
+	* config/aarch64/aarch64.md: Fix up aarch64_ra_sign_key type name change
+	and enum value.
+	* config/aarch64/aarch64.opt: Include aarch-common.h to import
+	type move.  Fix up name changes from factoring out common code and
+	data.
+	* config/arm/aarch-common-protos.h: Export factored out routines to both
+	backends.
+	* config/arm/aarch-common.cc: Include newly factored out types.
+	Move all mbranch-protection code and data structures from
+	aarch64.cc.
+	* config/arm/aarch-common.h: New header that declares types shared
+	between aarch32 and aarch64 backends.
+	* config/arm/arm-protos.h: Declare types and variables that are
+	made common to aarch64 and aarch32 backends - aarch_ra_sign_key,
+	aarch_ra_sign_scope and aarch_enable_bti.
+	* config/arm/arm.opt (config/arm/aarch-common.h): Include header.
+	(aarch_ra_sign_scope, aarch_enable_bti): Declare variable.
+	* config/arm/arm.cc: Add missing includes.
+
+2023-01-23  Tobias Burnus  <tobias@codesourcery.com>
+
+	* doc/install.texi (amdgcn, nvptx): Require newlib 4.3.0.
+
+2023-01-23  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/108449
+	* cgraphunit.cc (check_global_declaration): Do not turn
+	undefined statics into externs.
+
+2023-01-22  Dimitar Dimitrov  <dimitar@dinux.eu>
+
+	* config/pru/pru.h (CLZ_DEFINED_VALUE_AT_ZERO): Fix value for QI
+	and HI input modes.
+	* config/pru/pru.md (clz): Fix generated code for QI and HI
+	input modes.
+
+2023-01-22  Cupertino Miranda  <cupertino.miranda@oracle.com>
+
+	* config/v850/v850.cc (v850_select_section): Put const volatile
+	objects into read-only sections.
+
+2023-01-20  Tejas Belagod  <tejas.belagod@arm.com>
+
+	* config/aarch64/arm_neon.h (vmull_p64, vmull_high_p64, vaeseq_u8,
+	vaesdq_u8, vaesmcq_u8, vaesimcq_u8): Gate under "nothing+aes".
+	(vsha1*_u32, vsha256*_u32): Gate under "nothing+sha2".
+
+2023-01-20  Jakub Jelinek  <jakub@redhat.com>
+
+	PR tree-optimization/108457
+	* tree-ssa-loop-niter.cc (build_cltz_expr): Use
+	SCALAR_INT_TYPE_MODE (utype) directly as C[LT]Z_DEFINED_VALUE_AT_ZERO
+	argument instead of a temporary.  Formatting fixes.
+
+2023-01-19  Jakub Jelinek  <jakub@redhat.com>
+
+	PR tree-optimization/108447
+	* value-relation.cc (rr_union_table): Fix VREL_UNDEFINED row order.
+	(relation_tests): Add self-tests for relation_{intersect,union}
+	commutativity.
+	* selftest.h (relation_tests): Declare.
+	* function-tests.cc (test_ranges): Call it.
+
+2023-01-19  H.J. Lu  <hjl.tools@gmail.com>
+
+	PR target/108436
+	* config/i386/i386-expand.cc (ix86_expand_builtin): Check
+	invalid third argument to __builtin_ia32_prefetch.
+
+2023-01-19  Jakub Jelinek  <jakub@redhat.com>
+
+	PR middle-end/108459
+	* omp-expand.cc (expand_omp_for_init_counts): Use fold_build1 rather
+	than fold_unary for NEGATE_EXPR.
+
+2023-01-19  Christophe Lyon  <christophe.lyon@arm.com>
+
+	PR target/108411
+	* config/aarch64/aarch64.cc (aarch64_layout_arg): Improve
+	comment. Move assert about alignment a bit later.
+
+2023-01-19  Jakub Jelinek  <jakub@redhat.com>
+
+	PR tree-optimization/108440
+	* tree-ssa-forwprop.cc: Include gimple-range.h.
+	(simplify_rotate): For the forms with T2 wider than T and shift counts of
+	Y and B - Y add & (B - 1) masking for the rotate count if Y could be equal
+	to B.  For the forms with T2 wider than T and shift counts of
+	Y and (-Y) & (B - 1), don't punt if range could be [B, B2], but only if
+	range doesn't guarantee Y < B or Y = N * B.  If range doesn't guarantee
+	Y < B, also add & (B - 1) masking for the rotate count.  Use lazily created
+	pass specific ranger instead of get_global_range_query.
+	(pass_forwprop::execute): Disable that ranger at the end of pass if it has
+	been created.
+
+2023-01-19  Prathamesh Kulkarni  <prathamesh.kulkarni@linaro.org>
+
+	* config/aarch64/aarch64-simd.md (aarch64_simd_vec_set<mode>): Use
+	exact_log2 (INTVAL (operands[2])) >= 0 as condition for gating
+	the pattern.
+	(aarch64_simd_vec_copy_lane<mode>): Likewise.
+	(aarch64_simd_vec_copy_lane_<vswap_width_name><mode>): Likewise.
+
+2023-01-19  Alexandre Oliva  <oliva@adacore.com>
+
+	PR debug/106746
+	* sched-deps.cc (sched_analyze_2): Skip cselib address lookup
+	within debug insns.
+
+2023-01-18  Martin Jambor  <mjambor@suse.cz>
+
+	PR ipa/107944
+	* cgraph.cc (cgraph_node::remove): Check whether nodes up the
+	lcone_of chain also do not need the body.
+
+2023-01-18  Richard Biener  <rguenther@suse.de>
+
+	Revert:
+	2022-12-16  Richard Biener  <rguenther@suse.de>
+
+	PR middle-end/108086
+	* tree-inline.cc (remap_ssa_name): Do not unshare the
+	result from the decl_map.
+
+2023-01-18  Murray Steele  <murray.steele@arm.com>
+
+	PR target/108442
+	* config/arm/arm_mve.h (__arm_vst1q_p_u8): Use prefixed intrinsic
+	function.
+	(__arm_vst1q_p_s8): Likewise.
+	(__arm_vld1q_z_u8): Likewise.
+	(__arm_vld1q_z_s8): Likewise.
+	(__arm_vst1q_p_u16): Likewise.
+	(__arm_vst1q_p_s16): Likewise.
+	(__arm_vld1q_z_u16): Likewise.
+	(__arm_vld1q_z_s16): Likewise.
+	(__arm_vst1q_p_u32): Likewise.
+	(__arm_vst1q_p_s32): Likewise.
+	(__arm_vld1q_z_u32): Likewise.
+	(__arm_vld1q_z_s32): Likewise.
+	(__arm_vld1q_z_f16): Likewise.
+	(__arm_vst1q_p_f16): Likewise.
+	(__arm_vld1q_z_f32): Likewise.
+	(__arm_vst1q_p_f32): Likewise.
+
+2023-01-18  Takayuki 'January June' Suwa  <jjsuwa_sys3175@yahoo.co.jp>
+
+	* config/xtensa/xtensa.md (xorsi3_internal):
+	Rename from the original of "xorsi3".
+	(xorsi3): New expansion pattern that emits addition rather than
+	bitwise-XOR when the second source is a constant of -2147483648
+	if TARGET_DENSITY.
+
+2023-01-18  Kewen Lin  <linkw@linux.ibm.com>
+	    Andrew Pinski  <apinski@marvell.com>
+
+	PR target/108396
+	* config/rs6000/rs6000-overload.def (VEC_VSUBCUQ): Fix typo
+	vec_vsubcuqP with vec_vsubcuq.
+
+2023-01-18  Kewen Lin  <linkw@linux.ibm.com>
+
+	PR target/108348
+	* config/rs6000/rs6000.cc (rs6000_opaque_type_invalid_use_p): Add the
+	support for invalid uses of MMA opaque type in function arguments.
+
+2023-01-18  liuhongt  <hongtao.liu@intel.com>
+
+	PR target/55522
+	* config/i386/cygwin.h (ENDFILE_SPEC): Link crtfastmath.o
+	whenever -mdaz-ftz is specified. Don't link crtfastmath.o when
+	-share or -mno-daz-ftz is specified.
+	* config/i386/darwin.h (ENDFILE_SPEC): Ditto.
+	* config/i386/mingw32.h (ENDFILE_SPEC): Ditto.
+
+2023-01-17  Jose E. Marchesi  <jose.marchesi@oracle.com>
+
+	* config/bpf/bpf.cc (bpf_option_override): Disable
+	-fstack-protector.
+
+2023-01-17  Jakub Jelinek  <jakub@redhat.com>
+
+	PR tree-optimization/106523
+	* tree-ssa-forwprop.cc (simplify_rotate): For the
+	patterns with (-Y) & (B - 1) in one operand's shift
+	count and Y in another, if T2 has wider precision than T,
+	punt if Y could have a value in [B, B2 - 1] range.
+
+2023-01-16  H.J. Lu  <hjl.tools@gmail.com>
+
+	PR target/105980
+	* config/i386/i386.cc (x86_output_mi_thunk): Disable
+	-mforce-indirect-call for PIC in 32-bit mode.
+
+2023-01-16  Jan Hubicka  <hubicka@ucw.cz>
+
+	PR ipa/106077
+	* ipa-modref.cc (modref_access_analysis::analyze): Use
+	find_always_executed_bbs.
+	* ipa-sra.cc (process_scan_results): Likewise.
+	* ipa-utils.cc (stmt_may_terminate_function_p): New function.
+	(find_always_executed_bbs): New function.
+	* ipa-utils.h (stmt_may_terminate_function_p): Declare.
+	(find_always_executed_bbs): Declare.
+
+2023-01-16  Jan Hubicka  <jh@suse.cz>
+
+	* config/i386/i386.cc (ix86_vectorize_builtin_scatter): Guard scatter
+	by TARGET_USE_SCATTER.
+	* config/i386/i386.h (TARGET_USE_SCATTER_2PARTS,
+	TARGET_USE_SCATTER_4PARTS, TARGET_USE_SCATTER): New macros.
+	* config/i386/x86-tune.def (TARGET_USE_SCATTER_2PARTS,
+	TARGET_USE_SCATTER_4PARTS, TARGET_USE_SCATTER): New tunes.
+	(X86_TUNE_AVOID_256FMA_CHAINS, X86_TUNE_AVOID_512FMA_CHAINS): Disable
+	for znver4.  (X86_TUNE_USE_GATHER): Disable for zen4.
+
+2023-01-16  Richard Biener  <rguenther@suse.de>
+
+	PR target/55522
+	* config/sol2.h (ENDFILE_SPEC): Don't add crtfastmath.o for -shared.
+
+2023-01-16  Stam Markianos-Wright  <stam.markianos-wright@arm.com>
+
+	PR target/96795
+	PR target/107515
+	* config/arm/arm_mve.h (__ARM_mve_coerce2): Split types.
+	(__ARM_mve_coerce3): Likewise.
+
+2023-01-16  Andrew Carlotti  <andrew.carlotti@arm.com>
+
+	* tree-ssa-loop-niter.cc (build_popcount_expr): Add IFN support.
+
+2023-01-16  Andrew Carlotti  <andrew.carlotti@arm.com>
+
+	* tree-ssa-loop-niter.cc (number_of_iterations_cltz): New.
+	(number_of_iterations_bitcount): Add call to the above.
+	(number_of_iterations_exit_assumptions): Add EQ_EXPR case for
+	c[lt]z idiom recognition.
+
+2023-01-16  Andrew Carlotti  <andrew.carlotti@arm.com>
+
+	* doc/sourcebuild.texi: Add missing target attributes.
+
+2023-01-16  Andrew Carlotti  <andrew.carlotti@arm.com>
+
+	PR tree-optimization/94793
+	* tree-scalar-evolution.cc (expression_expensive_p): Add checks
+	for c[lt]z optabs.
+	* tree-ssa-loop-niter.cc (build_cltz_expr): New.
+	(number_of_iterations_cltz_complement): New.
+	(number_of_iterations_bitcount): Add call to the above.
+
+2023-01-16  Jonathan Wakely  <jwakely@redhat.com>
+
+	* doc/extend.texi (Common Function Attributes): Fix grammar.
+
+2023-01-16  Jakub Jelinek  <jakub@redhat.com>
+
+	PR other/108413
+	* config/riscv/riscv-vsetvl.h: Add space in between Copyright and (C).
+	* config/riscv/riscv-vsetvl.cc: Likewise.
+
+2023-01-16  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/105593
+	* config/i386/xmmintrin.h (_mm_undefined_ps): Temporarily
+	disable -Winit-self using pragma GCC diagnostic ignored.
+	* config/i386/emmintrin.h (_mm_undefined_pd, _mm_undefined_si128):
+	Likewise.
+	* config/i386/avxintrin.h (_mm256_undefined_pd, _mm256_undefined_ps,
+	_mm256_undefined_si256): Likewise.
+	* config/i386/avx512fintrin.h (_mm512_undefined_pd,
+	_mm512_undefined_ps, _mm512_undefined_epi32): Likewise.
+	* config/i386/avx512fp16intrin.h (_mm_undefined_ph,
+	_mm256_undefined_ph, _mm512_undefined_ph): Likewise.
+
+2023-01-16  Kewen Lin  <linkw@linux.ibm.com>
+
+	PR target/108272
+	* config/rs6000/rs6000.cc (rs6000_opaque_type_invalid_use_p): Add the
+	support for invalid uses in inline asm, factor out the checking and
+	erroring to lambda function check_and_error_invalid_use.
+
 2023-01-15  Aldy Hernandez  <aldyh@redhat.com>
 
 	PR tree-optimization/107608
diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP
index 748a3e0..aa6d864 100644
--- a/gcc/DATESTAMP
+++ b/gcc/DATESTAMP
@@ -1 +1 @@
-20230116
+20230131
diff --git a/gcc/Makefile.in b/gcc/Makefile.in
index bb8e9f5..487e506 100644
--- a/gcc/Makefile.in
+++ b/gcc/Makefile.in
@@ -532,7 +532,11 @@ LINKER_PLUGIN_API_H = $(srcdir)/../include/plugin-api.h
 # Default native SYSTEM_HEADER_DIR, to be overridden by targets.
 NATIVE_SYSTEM_HEADER_DIR = @NATIVE_SYSTEM_HEADER_DIR@
 # Default cross SYSTEM_HEADER_DIR, to be overridden by targets.
-CROSS_SYSTEM_HEADER_DIR = @CROSS_SYSTEM_HEADER_DIR@
+ifeq (@includedir@,$(prefix)/include)
+  CROSS_SYSTEM_HEADER_DIR = @CROSS_SYSTEM_HEADER_DIR@
+else
+  CROSS_SYSTEM_HEADER_DIR = @includedir@
+endif
 
 # autoconf sets SYSTEM_HEADER_DIR to one of the above.
 # Purge it of unnecessary internal relative paths
diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog
index 11501640..cebcb42 100644
--- a/gcc/ada/ChangeLog
+++ b/gcc/ada/ChangeLog
@@ -1,3 +1,101 @@
+2023-01-16  Marc Poulhiès  <poulhies@adacore.com>
+
+	* gcc-interface/Make-lang.in: Update copyright years.
+	* gcc-interface/Makefile.in: Likewise.
+	* gcc-interface/ada-builtin-types.def: Likewise.
+	* gcc-interface/ada-builtins.def: Likewise.
+	* gcc-interface/ada-tree.def: Likewise.
+	* gcc-interface/ada-tree.h: Likewise.
+	* gcc-interface/ada.h: Likewise.
+	* gcc-interface/config-lang.in: Likewise.
+	* gcc-interface/cuintp.cc: Likewise.
+	* gcc-interface/decl.cc: Likewise.
+	* gcc-interface/gadaint.h: Likewise.
+	* gcc-interface/gigi.h: Likewise.
+	* gcc-interface/lang-specs.h: Likewise.
+	* gcc-interface/lang.opt: Likewise.
+	* gcc-interface/misc.cc: Likewise.
+	* gcc-interface/system.ads: Likewise.
+	* gcc-interface/targtyps.cc: Likewise.
+	* gcc-interface/trans.cc: Likewise.
+	* gcc-interface/utils.cc: Likewise.
+	* gcc-interface/utils2.cc: Likewise.
+
+2023-01-16  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* exp_ch3.adb (Make_Allocator_For_Return): Fix typo in comment.
+
+2023-01-16  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* exp_ch3.adb (Make_Allocator_For_Return): Convert the expression
+	to the return object's type in the constrained array case as well.
+
+2023-01-16  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* exp_ch3.adb (Expand_N_Object_Declaration): For a class-wide non-
+	interface stand-alone object initialized by a function call, call
+	Remove_Side_Effects on the expression to capture the result.
+
+2023-01-16  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* exp_util.ads (Has_Tag_Of_Type): Declare.
+	* exp_util.adb (Has_Tag_Of_Type): Move to package level.  Recurse on
+	qualified expressions.
+	* exp_ch3.adb (Expand_N_Object_Declaration): Use a static reference
+	to the interface tag in more cases for class-wide interface objects.
+
+2023-01-16  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* exp_util.adb (Make_CW_Equivalent_Type.Has_Tag_Of_Type): Fix pasto.
+
+2023-01-16  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* exp_util.adb (Is_Temporary_For_Interface_Object): Delete.
+	(Is_Finalizable_Transient.Is_Aliased): Deal with the specific case
+	of temporaries generated for interface objects.
+
+2023-01-16  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* exp_ch3.adb (Expand_N_Object_Declaration): Do not generate a back-
+	and-forth displacement of the object's address when using a renaming
+	for an interface object with an expression of the same type.
+	* exp_ch4.adb (Expand_Allocator_Expression): Do not remove the side
+	effects of the expression up front for the simple allocators. Do not
+	call the Adjust primitive if the expression is a function call.
+	* exp_ch6.adb (Expand_Ctrl_Function_Call): Do not expand the call
+	unnecessarily for a special return object.
+	(Expand_Simple_Function_Return): Restore the displacement of the
+	return object's address in the case where the expression is the call
+	to a function whose result type is a type that needs finalization.
+	* exp_util.adb (Expand_Subtype_From_Expr): Do not remove the side
+	effects of the expression before calling Make_Subtype_From_Expr.
+	(Make_CW_Equivalent_Type): If the expression has the tag of its type
+	and this type has a uniform size, use 'Object_Size of this type in
+	lieu of 'Size of the expression to compute the expression's size.
+
+2023-01-16  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* exp_ch3.adb (Make_Allocator_For_Return): Put back an interface
+	conversion for expressions with non-interface class-wide type.
+
+2023-01-16  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* exp_ch3.adb (Expand_N_Object_Declaration): Also optimize aliased
+	objects if their nominal subtype is not an unconstrained array.
+
+2023-01-16  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* exp_ch3.adb (Expand_N_Object_Declaration): Factor out conditions
+	needed for an initializating expression that is a function call to
+	be renamable into the Is_Renamable_Function_Call predicate.
+	Use it to implement the renaming in the case of class-wide interface
+	objects.  Remove an interface conversion on all paths, separate and
+	optimize the renaming path in the special expansion for interfaces.
+	(Is_Renamable_Function_Call): New predicate.
+	(Make_Allocator_For_Return): Put back an interface conversion.
+	* exp_ch6.adb (Apply_CW_Accessibility_Check): Remove useless access
+	checks on RE_Tag_Ptr.
+
 2023-01-09  Arnaud Charlet  <charlet@adacore.com>
 
 	* accessibility.adb, accessibility.ads, ada_get_targ.adb: Update copyright year.
diff --git a/gcc/ada/exp_ch3.adb b/gcc/ada/exp_ch3.adb
index f107b7e..abe71b2 100644
--- a/gcc/ada/exp_ch3.adb
+++ b/gcc/ada/exp_ch3.adb
@@ -6306,6 +6306,38 @@ package body Exp_Ch3 is
       --  Generate all initialization actions for return object Def_Id. Any
       --  new code is inserted after node After.
 
+      function Is_Renamable_Function_Call (Expr : Node_Id) return Boolean;
+      --  If we are not at library level and the object declaration originally
+      --  appears in the form:
+
+      --    Obj : Typ := Func (...);
+
+      --  and has been rewritten as the dereference of a captured reference
+      --  to the function result built either on the primary or the secondary
+      --  stack, then the declaration can be rewritten as the renaming of this
+      --  dereference:
+
+      --    type Ann is access all Typ;
+      --    Rnn : constant Axx := Func (...)'reference;
+      --    Obj : Typ renames Rnn.all;
+
+      --  This will avoid making an extra copy and, in the case where Typ needs
+      --  finalization, a pair of calls to the Adjust and Finalize primitives,
+      --  or Deep_Adjust and Deep_Finalize routines, depending on whether Typ
+      --  has components that themselves need finalization.
+
+      --  However, in the case of a special return object, we need to make sure
+      --  that the object Rnn is recognized by the Is_Related_To_Func_Return
+      --  predicate; otherwise, if it is of a type that needs finalization,
+      --  then Requires_Cleanup_Actions would return true because of this and
+      --  Build_Finalizer would finalize it prematurely because of this (see
+      --  also Expand_Simple_Function_Return for the same test in the case of
+      --  a simple return).
+
+      --  Finally, in the case of a special return object, we also need to make
+      --  sure that the two functions return on the same stack, otherwise we
+      --  would create a dangling reference.
+
       function Make_Allocator_For_Return (Expr : Node_Id) return Node_Id;
       --  Make an allocator for a return object initialized with Expr
 
@@ -7100,12 +7132,28 @@ package body Exp_Ch3 is
          end if;
       end Initialize_Return_Object;
 
+      --------------------------------
+      -- Is_Renamable_Function_Call --
+      --------------------------------
+
+      function Is_Renamable_Function_Call (Expr : Node_Id) return Boolean is
+      begin
+         return not Is_Library_Level_Entity (Def_Id)
+           and then Is_Captured_Function_Call (Expr)
+           and then (not Special_Ret_Obj
+                      or else
+                        (Is_Related_To_Func_Return (Entity (Prefix (Expr)))
+                          and then Needs_Secondary_Stack (Etype (Expr)) =
+                                   Needs_Secondary_Stack (Etype (Func_Id))));
+      end Is_Renamable_Function_Call;
+
       -------------------------------
       -- Make_Allocator_For_Return --
       -------------------------------
 
       function Make_Allocator_For_Return (Expr : Node_Id) return Node_Id is
-         Alloc : Node_Id;
+         Alloc      : Node_Id;
+         Alloc_Expr : Entity_Id;
 
       begin
          --  If the return object's declaration includes an expression and the
@@ -7131,18 +7179,32 @@ package body Exp_Ch3 is
                Apply_CW_Accessibility_Check (Expr, Func_Id);
             end if;
 
+            Alloc_Expr := New_Copy_Tree (Expr);
+
+            --  In the constrained array case, deal with a potential sliding.
+            --  In the interface case, put back a conversion that we may have
+            --  removed earlier in the processing.
+
+            if (Ekind (Typ) = E_Array_Subtype
+                 or else (Is_Interface (Typ)
+                           and then Is_Class_Wide_Type (Etype (Alloc_Expr))))
+              and then Typ /= Etype (Alloc_Expr)
+            then
+               Alloc_Expr := Convert_To (Typ, Alloc_Expr);
+            end if;
+
             --  We always use the type of the expression for the qualified
             --  expression, rather than the return object's type. We cannot
             --  always use the return object's type because the expression
-            --  might be of a specific type and the result object mignt not.
+            --  might be of a specific type and the return object mignt not.
 
             Alloc :=
               Make_Allocator (Loc,
                 Expression =>
                   Make_Qualified_Expression (Loc,
                     Subtype_Mark =>
-                      New_Occurrence_Of (Etype (Expr), Loc),
-                    Expression   => New_Copy_Tree (Expr)));
+                      New_Occurrence_Of (Etype (Alloc_Expr), Loc),
+                    Expression   => Alloc_Expr));
 
          else
             Alloc :=
@@ -7479,12 +7541,42 @@ package body Exp_Ch3 is
          then
             pragma Assert (Is_Class_Wide_Type (Typ));
 
+            --  If the original node of the expression was a conversion
+            --  to this specific class-wide interface type then restore
+            --  the original node because we must copy the object before
+            --  displacing the pointer to reference the secondary tag
+            --  component. This code must be kept synchronized with the
+            --  expansion done by routine Expand_Interface_Conversion
+
+            if not Comes_From_Source (Expr)
+              and then Nkind (Expr) = N_Explicit_Dereference
+              and then Nkind (Original_Node (Expr)) = N_Type_Conversion
+              and then Etype (Original_Node (Expr)) = Typ
+            then
+               Rewrite (Expr, Original_Node (Expression (N)));
+            end if;
+
+            --  Avoid expansion of redundant interface conversion
+
+            if Nkind (Expr) = N_Type_Conversion
+              and then Etype (Expr) = Typ
+            then
+               Expr_Q := Expression (Expr);
+            else
+               Expr_Q := Expr;
+            end if;
+
+            --  We may use a renaming if the initialization expression is a
+            --  captured function call that meets a few conditions.
+
+            Rewrite_As_Renaming := Is_Renamable_Function_Call (Expr_Q);
+
             --  If the object is a special return object, then bypass special
             --  treatment of class-wide interface initialization below. In this
-            --  case, the expansion of the return statement will take care of
-            --  creating the object (via allocator) and initializing it.
+            --  case, the expansion of the return object will take care of this
+            --  initialization via the expansion of the allocator.
 
-            if Special_Ret_Obj then
+            if Special_Ret_Obj and then not Rewrite_As_Renaming then
 
                --  If the type needs finalization and is not inherently
                --  limited, then the target is adjusted after the copy
@@ -7499,6 +7591,13 @@ package body Exp_Ch3 is
                       Typ     => Base_Typ);
                end if;
 
+            --  Renaming an expression of the object's type is immediate
+
+            elsif Rewrite_As_Renaming
+              and then Base_Type (Etype (Expr_Q)) = Base_Type (Typ)
+            then
+               null;
+
             elsif Tagged_Type_Expansion then
                declare
                   Iface : constant Entity_Id := Root_Type (Typ);
@@ -7511,57 +7610,74 @@ package body Exp_Ch3 is
                   Tag_Comp     : Node_Id;
 
                begin
-                  --  If the original node of the expression was a conversion
-                  --  to this specific class-wide interface type then restore
-                  --  the original node because we must copy the object before
-                  --  displacing the pointer to reference the secondary tag
-                  --  component. This code must be kept synchronized with the
-                  --  expansion done by routine Expand_Interface_Conversion
-
-                  if not Comes_From_Source (Expr)
-                    and then Nkind (Expr) = N_Explicit_Dereference
-                    and then Nkind (Original_Node (Expr)) = N_Type_Conversion
-                    and then Etype (Original_Node (Expr)) = Typ
-                  then
-                     Rewrite (Expr, Original_Node (Expression (N)));
+                  Expr_Typ := Base_Type (Etype (Expr_Q));
+                  if Is_Class_Wide_Type (Expr_Typ) then
+                     Expr_Typ := Root_Type (Expr_Typ);
                   end if;
 
-                  --  Avoid expansion of redundant interface conversion
+                  --  Rename limited objects since they cannot be copied
 
-                  if Is_Interface (Etype (Expr))
-                    and then Nkind (Expr) = N_Type_Conversion
-                    and then Etype (Expr) = Typ
-                  then
-                     Expr_Q := Expression (Expr);
-                  else
-                     Expr_Q := Expr;
+                  if Is_Limited_Record (Expr_Typ) then
+                     Rewrite_As_Renaming := True;
                   end if;
 
-                  Obj_Id   := Make_Temporary (Loc, 'D', Expr_Q);
-                  Expr_Typ := Base_Type (Etype (Expr_Q));
+                  Obj_Id := Make_Temporary (Loc, 'D', Expr_Q);
 
-                  if Is_Class_Wide_Type (Expr_Typ) then
-                     Expr_Typ := Root_Type (Expr_Typ);
-                  end if;
+                  --  Replace
+                  --     IW : I'Class := Expr;
+                  --  by
+                  --     Dnn : Tag renames Tag_Ptr!(Expr'Address).all;
+                  --     type Ityp is not null access I'Class;
+                  --     Rnn : constant Ityp :=
+                  --             Ityp!(Displace (Dnn'Address, I'Tag));
+                  --     IW : I'Class renames Rnn.all;
+
+                  if Rewrite_As_Renaming then
+                     New_Expr :=
+                       Make_Explicit_Dereference (Loc,
+                         Unchecked_Convert_To (RTE (RE_Tag_Ptr),
+                           Make_Attribute_Reference (Loc,
+                             Prefix => Relocate_Node (Expr_Q),
+                             Attribute_Name => Name_Address)));
+
+                     --  Suppress junk access checks on RE_Tag_Ptr
+
+                     Insert_Action (N,
+                       Make_Object_Renaming_Declaration (Loc,
+                         Defining_Identifier => Obj_Id,
+                         Subtype_Mark        =>
+                           New_Occurrence_Of (RTE (RE_Tag), Loc),
+                         Name                => New_Expr),
+                       Suppress => Access_Check);
+
+                     --  Dynamically reference the tag associated with the
+                     --  interface.
+
+                     Tag_Comp :=
+                       Make_Function_Call (Loc,
+                         Name => New_Occurrence_Of (RTE (RE_Displace), Loc),
+                         Parameter_Associations => New_List (
+                           Make_Attribute_Reference (Loc,
+                             Prefix => New_Occurrence_Of (Obj_Id, Loc),
+                             Attribute_Name => Name_Address),
+                           New_Occurrence_Of
+                             (Node (First_Elmt (Access_Disp_Table (Iface))),
+                              Loc)));
 
                   --  Replace
-                  --     CW : I'Class := Obj;
+                  --     IW : I'Class := Expr;
                   --  by
-                  --     Tmp : Typ := Obj;
+                  --     Dnn : Typ := Expr;
                   --     type Ityp is not null access I'Class;
-                  --     Rnn : constant Ityp := Ityp (Tmp.I_Tag'Address);
-                  --     CW  : I'Class renames Rnn.all;
+                  --     Rnn : constant Ityp := Ityp (Dnn.I_Tag'Address);
+                  --     IW  : I'Class renames Rnn.all;
 
-                  if Comes_From_Source (Expr_Q)
-                    and then Is_Entity_Name (Expr_Q)
-                    and then not Is_Interface (Expr_Typ)
+                  elsif Has_Tag_Of_Type (Expr_Q)
                     and then Interface_Present_In_Ancestor (Expr_Typ, Typ)
                     and then (Expr_Typ = Etype (Expr_Typ)
                                or else not
                                  Is_Variable_Size_Record (Etype (Expr_Typ)))
                   then
-                     --  Copy the object
-
                      Insert_Action (N,
                        Make_Object_Declaration (Loc,
                          Defining_Identifier => Obj_Id,
@@ -7580,14 +7696,14 @@ package body Exp_Ch3 is
                              (Find_Interface_Tag (Expr_Typ, Iface), Loc));
 
                   --  Replace
-                  --     IW : I'Class := Obj;
+                  --     IW : I'Class := Expr;
                   --  by
                   --     type Equiv_Record is record ... end record;
                   --     implicit subtype CW is <Class_Wide_Subtype>;
-                  --     Tmp : CW := CW!(Obj);
+                  --     Dnn : CW := CW!(Expr);
                   --     type Ityp is not null access I'Class;
                   --     Rnn : constant Ityp :=
-                  --             Ityp!(Displace (Tmp'Address, I'Tag));
+                  --             Ityp!(Displace (Dnn'Address, I'Tag));
                   --     IW : I'Class renames Rnn.all;
 
                   else
@@ -7600,13 +7716,10 @@ package body Exp_Ch3 is
                         Subtype_Indic => Obj_Def,
                         Exp           => Expr_Q);
 
-                     if not Is_Interface (Etype (Expr_Q)) then
-                        New_Expr := Relocate_Node (Expr_Q);
-
                      --  For interface types we use 'Address which displaces
-                     --  the pointer to the base of the object (if required)
+                     --  the pointer to the base of the object (if required).
 
-                     else
+                     if Is_Interface (Etype (Expr_Q)) then
                         New_Expr :=
                           Unchecked_Convert_To (Etype (Obj_Def),
                             Make_Explicit_Dereference (Loc,
@@ -7614,33 +7727,23 @@ package body Exp_Ch3 is
                                 Make_Attribute_Reference (Loc,
                                   Prefix => Relocate_Node (Expr_Q),
                                   Attribute_Name => Name_Address))));
-                     end if;
-
-                     --  Copy the object
 
-                     if not Is_Limited_Record (Expr_Typ) then
-                        Insert_Action (N,
-                          Make_Object_Declaration (Loc,
-                            Defining_Identifier => Obj_Id,
-                            Object_Definition   =>
-                              New_Occurrence_Of (Etype (Obj_Def), Loc),
-                            Expression => New_Expr));
-
-                     --  Rename limited type object since they cannot be copied
-                     --  This case occurs when the initialization expression
-                     --  has been previously expanded into a temporary object.
+                     --  For other types, no displacement is needed
 
                      else
-                        Insert_Action (N,
-                          Make_Object_Renaming_Declaration (Loc,
-                            Defining_Identifier => Obj_Id,
-                            Subtype_Mark        =>
-                              New_Occurrence_Of (Etype (Obj_Def), Loc),
-                            Name                =>
-                              Unchecked_Convert_To
-                                (Etype (Obj_Def), New_Expr)));
+                        New_Expr := Relocate_Node (Expr_Q);
                      end if;
 
+                     --  Suppress junk access checks on RE_Tag_Ptr
+
+                     Insert_Action (N,
+                       Make_Object_Declaration (Loc,
+                         Defining_Identifier => Obj_Id,
+                         Object_Definition   =>
+                           New_Occurrence_Of (Etype (Obj_Def), Loc),
+                         Expression          => New_Expr),
+                       Suppress => Access_Check);
+
                      --  Dynamically reference the tag associated with the
                      --  interface.
 
@@ -7684,6 +7787,7 @@ package body Exp_Ch3 is
                   Set_Prefix (Tag_Comp, New_Occurrence_Of (Ptr_Obj_Id, Loc));
                   Expr_Q := Tag_Comp;
                   Set_Etype (Expr_Q, Typ);
+                  Set_Parent (Expr_Q, N);
 
                   Rewrite_As_Renaming := True;
                end;
@@ -7695,6 +7799,25 @@ package body Exp_Ch3 is
          --  Common case of explicit object initialization
 
          else
+            --  Small optimization: if the expression is a function call and
+            --  the object is stand-alone, not declared at library level and of
+            --  a class-wide type, then we capture the result of the call into
+            --  a temporary, with the benefit that, if the result's type does
+            --  not need finalization, nothing will be finalized and, if it
+            --  does, the temporary only will be finalized by means of a direct
+            --  call to the Finalize primitive if the result's type is not a
+            --  class-wide type; whereas, in both cases, the stand-alone object
+            --  itself would be finalized by means of a dispatching call to the
+            --  Deep_Finalize routine.
+
+            if Nkind (Expr_Q) = N_Function_Call
+              and then not Special_Ret_Obj
+              and then not Is_Library_Level_Entity (Def_Id)
+              and then Is_Class_Wide_Type (Typ)
+            then
+               Remove_Side_Effects (Expr_Q);
+            end if;
+
             --  In most cases, we must check that the initial value meets any
             --  constraint imposed by the declared type. However, there is one
             --  very important exception to this rule. If the entity has an
@@ -7863,66 +7986,26 @@ package body Exp_Ch3 is
             Rewrite_As_Renaming :=
 
               --  The declaration cannot be rewritten if it has got constraints
-              --  in other words the nominal subtype must be unconstrained.
 
               Is_Entity_Name (Original_Node (Obj_Def))
 
-                --  The aliased case has to be excluded because the expression
-                --  will not be aliased in the general case.
-
-                and then not Aliased_Present (N)
-
-                --  If the object declaration originally appears in the form
-
-                --    Obj : Typ := Func (...);
-
-                --  and has been rewritten as the dereference of a reference
-                --  to the function result built either on the primary or the
-                --  secondary stack, then the declaration can be rewritten as
-                --  the renaming of this dereference:
-
-                --    type Ann is access all Typ;
-                --    Rnn : constant Axx := Func (...)'reference;
-                --    Obj : Typ renames Rnn.all;
+                --  Nor if it is effectively an unconstrained declaration
 
-                --  This avoids an extra copy and, in the case where Typ needs
-                --  finalization, a pair of Adjust/Finalize calls (see below).
+                and then not (Is_Array_Type (Typ)
+                               and then Is_Constr_Subt_For_UN_Aliased (Typ))
 
-                --  However, in the case of a special return object, we need to
-                --  make sure that the object Rnn is properly recognized by the
-                --  Is_Related_To_Func_Return predicate; otherwise, if it is of
-                --  a type that needs finalization, Requires_Cleanup_Actions
-                --  would return true because of this and Build_Finalizer would
-                --  finalize it prematurely (see Expand_Simple_Function_Return
-                --  for the same test in the case of a simple return).
-
-                --  Moreover, in the case of a special return object, we also
-                --  need to make sure that the two functions return on the same
-                --  stack, otherwise we would create a dangling reference.
+                --  We may use a renaming if the initialization expression is a
+                --  captured function call that meets a few conditions.
 
                 and then
-                  ((not Is_Library_Level_Entity (Def_Id)
-                     and then Is_Captured_Function_Call (Expr_Q)
-                     and then
-                       (not Special_Ret_Obj
-                         or else
-                          (Is_Related_To_Func_Return (Entity (Prefix (Expr_Q)))
-                            and then Needs_Secondary_Stack (Etype (Expr_Q)) =
-                                     Needs_Secondary_Stack (Etype (Func_Id)))))
-
-                   --  If the initializing expression is a variable with the
-                   --  flag OK_To_Rename set, then transform:
-
-                   --     Obj : Typ := Expr;
-
-                   --  into
+                  (Is_Renamable_Function_Call (Expr_Q)
 
-                   --     Obj : Typ renames Expr;
+                   --  Or else if it is a variable with OK_To_Rename set
 
                    or else (OK_To_Rename_Ref (Expr_Q)
                              and then not Special_Ret_Obj)
 
-                   --  Likewise if it is a slice of such a variable
+                   --  Or else if it is a slice of such a variable
 
                    or else (Nkind (Expr_Q) = N_Slice
                              and then OK_To_Rename_Ref (Prefix (Expr_Q))
@@ -8117,8 +8200,8 @@ package body Exp_Ch3 is
 
       if Is_Build_In_Place_Return_Object (Def_Id) then
          declare
-            Init_Stmt       : Node_Id;
-            Obj_Acc_Formal  : Entity_Id;
+            Init_Stmt      : Node_Id;
+            Obj_Acc_Formal : Entity_Id;
 
          begin
             --  Retrieve the implicit access parameter passed by the caller
diff --git a/gcc/ada/exp_ch4.adb b/gcc/ada/exp_ch4.adb
index d3a4f57..31823ea 100644
--- a/gcc/ada/exp_ch4.adb
+++ b/gcc/ada/exp_ch4.adb
@@ -698,11 +698,14 @@ package body Exp_Ch4 is
          --  recursion and inappropriate call to Initialize.
 
          --  We don't want to remove side effects when the expression must be
-         --  built in place. In the case of a build-in-place function call,
-         --  that could lead to a duplication of the call, which was already
-         --  substituted for the allocator.
+         --  built in place and we don't need it when there is no storage pool
+         --  or this is a return/secondary stack allocation.
 
-         if not Aggr_In_Place then
+         if not Aggr_In_Place
+           and then Present (Storage_Pool (N))
+           and then not Is_RTE (Storage_Pool (N), RE_RS_Pool)
+           and then not Is_RTE (Storage_Pool (N), RE_SS_Pool)
+         then
             Remove_Side_Effects (Exp);
          end if;
 
@@ -747,7 +750,7 @@ package body Exp_Ch4 is
 
          --  Processing for allocators returning non-interface types
 
-         if not Is_Interface (Directly_Designated_Type (PtrT)) then
+         if not Is_Interface (DesigT) then
             if Aggr_In_Place then
                Temp_Decl :=
                  Make_Object_Declaration (Loc,
@@ -960,8 +963,9 @@ package body Exp_Ch4 is
 
          if Needs_Finalization (DesigT)
            and then Needs_Finalization (T)
-           and then not Aggr_In_Place
            and then not Is_Limited_View (T)
+           and then not Aggr_In_Place
+           and then Nkind (Exp) /= N_Function_Call
            and then not For_Special_Return_Object (N)
          then
             --  An unchecked conversion is needed in the classwide case because
@@ -993,7 +997,7 @@ package body Exp_Ch4 is
          --  component containing the secondary dispatch table of the interface
          --  type.
 
-         if Is_Interface (Directly_Designated_Type (PtrT)) then
+         if Is_Interface (DesigT) then
             Displace_Allocator_Pointer (N);
          end if;
 
diff --git a/gcc/ada/exp_ch6.adb b/gcc/ada/exp_ch6.adb
index 7a309e8..7abf25e 100644
--- a/gcc/ada/exp_ch6.adb
+++ b/gcc/ada/exp_ch6.adb
@@ -687,7 +687,11 @@ package body Exp_Ch6 is
       Loc : constant Source_Ptr := Sloc (Exp);
 
    begin
+       --  CodePeer does not do anything useful on Ada.Tags.Type_Specific_Data
+       --  components.
+
       if Ada_Version >= Ada_2005
+        and then not CodePeer_Mode
         and then Tagged_Type_Expansion
         and then not Scope_Suppress.Suppress (Accessibility_Check)
         and then
@@ -770,20 +774,18 @@ package body Exp_Ch6 is
                    Attribute_Name => Name_Tag);
             end if;
 
-            --  CodePeer does not do anything useful with
-            --  Ada.Tags.Type_Specific_Data components.
-
-            if not CodePeer_Mode then
-               Insert_Action (Exp,
-                 Make_Raise_Program_Error (Loc,
-                   Condition =>
-                     Make_Op_Gt (Loc,
-                       Left_Opnd  => Build_Get_Access_Level (Loc, Tag_Node),
-                       Right_Opnd =>
-                         Make_Integer_Literal (Loc,
-                           Scope_Depth (Enclosing_Dynamic_Scope (Func)))),
-                   Reason    => PE_Accessibility_Check_Failed));
-            end if;
+            --  Suppress junk access chacks on RE_Tag_Ptr
+
+            Insert_Action (Exp,
+              Make_Raise_Program_Error (Loc,
+                Condition =>
+                  Make_Op_Gt (Loc,
+                    Left_Opnd  => Build_Get_Access_Level (Loc, Tag_Node),
+                    Right_Opnd =>
+                      Make_Integer_Literal (Loc,
+                        Scope_Depth (Enclosing_Dynamic_Scope (Func)))),
+                Reason    => PE_Accessibility_Check_Failed),
+              Suppress => Access_Check);
          end;
       end if;
    end Apply_CW_Accessibility_Check;
@@ -5131,14 +5133,11 @@ package body Exp_Ch6 is
 
       --  Another optimization: if the returned value is used to initialize an
       --  object, then no need to copy/readjust/finalize, we can initialize it
-      --  in place. However, if the call returns on the secondary stack or this
-      --  is a special return object, then we need the expansion because we'll
-      --  be renaming the temporary as the (permanent) object.
+      --  in place. However, if the call returns on the secondary stack, then
+      --  we need the expansion because we'll be renaming the temporary as the
+      --  (permanent) object.
 
-      if Nkind (Par) = N_Object_Declaration
-        and then not Use_Sec_Stack
-        and then not Is_Special_Return_Object (Defining_Entity (Par))
-      then
+      if Nkind (Par) = N_Object_Declaration and then not Use_Sec_Stack then
          return;
       end if;
 
@@ -6743,7 +6742,7 @@ package body Exp_Ch6 is
             null;
 
          --  Optimize the case where the result is a function call that also
-         --  returns on the secondary stack. In this case the result is already
+         --  returns on the secondary stack; in this case the result is already
          --  on the secondary stack and no further processing is required.
 
          elsif Exp_Is_Function_Call
@@ -6779,13 +6778,14 @@ package body Exp_Ch6 is
          --  gigi is not able to properly allocate class-wide types.
 
          --  But optimize the case where the result is a function call that
-         --  also needs finalization. In this case the result can directly be
+         --  also needs finalization; in this case the result can directly be
          --  allocated on the secondary stack and no further processing is
-         --  required.
+         --  required, unless the returned object is an interface.
 
          elsif CW_Or_Needs_Finalization (Utyp)
-           and then not (Exp_Is_Function_Call
-                          and then Needs_Finalization (Exp_Typ))
+           and then (Is_Interface (R_Type)
+                      or else not (Exp_Is_Function_Call
+                                    and then Needs_Finalization (Exp_Typ)))
          then
             declare
                Acc_Typ : constant Entity_Id := Make_Temporary (Loc, 'A');
diff --git a/gcc/ada/exp_util.adb b/gcc/ada/exp_util.adb
index cac0d84..80c01bf 100644
--- a/gcc/ada/exp_util.adb
+++ b/gcc/ada/exp_util.adb
@@ -168,11 +168,6 @@ package body Exp_Util is
    --  Force evaluation of bounds of a slice, which may be given by a range
    --  or by a subtype indication with or without a constraint.
 
-   function Is_Temporary_For_Interface_Object
-     (Obj_Id : Entity_Id) return Boolean;
-   --  Determine whether Obj_Id is a temporary created for the handling of a
-   --  (class-wide) interface object.
-
    function Is_Uninitialized_Aggregate
      (Exp : Node_Id;
       T   : Entity_Id) return Boolean;
@@ -5820,7 +5815,6 @@ package body Exp_Util is
          --  discriminants.
 
          else
-            Remove_Side_Effects (Exp);
             Rewrite (Subtype_Indic,
               Make_Subtype_From_Expr (Exp, Underlying_Record_View (Unc_Type)));
          end if;
@@ -5885,7 +5879,6 @@ package body Exp_Util is
          end if;
 
       else
-         Remove_Side_Effects (Exp);
          Rewrite (Subtype_Indic,
            Make_Subtype_From_Expr (Exp, Unc_Type, Related_Id));
       end if;
@@ -7193,6 +7186,63 @@ package body Exp_Util is
       end if;
    end Has_Access_Constraint;
 
+   ---------------------
+   -- Has_Tag_Of_Type --
+   ---------------------
+
+   function Has_Tag_Of_Type (Exp : Node_Id) return Boolean is
+      Typ : constant Entity_Id := Etype (Exp);
+
+   begin
+      pragma Assert (Is_Tagged_Type (Typ));
+
+      --  The tag of an object of a class-wide type is that of its
+      --  initialization expression.
+
+      if Is_Class_Wide_Type (Typ) then
+         return False;
+      end if;
+
+      --  The tag of a stand-alone object of a specific tagged type T
+      --  identifies T.
+
+      if Is_Entity_Name (Exp)
+        and then Ekind (Entity (Exp)) in E_Constant | E_Variable
+      then
+         return True;
+
+      else
+         case Nkind (Exp) is
+            --  The tag of a component or an aggregate of a specific tagged
+            --  type T identifies T.
+
+            when N_Indexed_Component
+              |  N_Selected_Component
+              |  N_Aggregate
+            =>
+               return True;
+
+            --  The tag of the result returned by a function whose result
+            --  type is a specific tagged type T identifies T.
+
+            when N_Function_Call =>
+               return True;
+
+            when N_Explicit_Dereference =>
+               return Is_Captured_Function_Call (Exp);
+
+            --  For a tagged type, the operand of a qualified expression
+            --  shall resolve to be of the type of the expression.
+
+            when N_Qualified_Expression =>
+               return Has_Tag_Of_Type (Expression (Exp));
+
+            when others =>
+               return False;
+         end case;
+      end if;
+   end Has_Tag_Of_Type;
+
    --------------------
    -- Homonym_Number --
    --------------------
@@ -8399,6 +8449,23 @@ package body Exp_Util is
                Search (Name (Ren_Decl));
             end if;
 
+            --  For renamings generated by Expand_N_Object_Declaration to deal
+            --  with (class-wide) interface objects, there is an intermediate
+            --  temporary of an anonymous access type used to hold the result
+            --  of the displacement of the address of the renamed object.
+
+            if Present (Ren_Obj)
+              and then Ekind (Ren_Obj) = E_Constant
+              and then Is_Itype (Etype (Ren_Obj))
+              and then Ekind (Etype (Ren_Obj)) = E_Anonymous_Access_Type
+              and then
+                Is_Class_Wide_Type (Directly_Designated_Type (Etype (Ren_Obj)))
+              and then
+                Is_Interface (Directly_Designated_Type (Etype (Ren_Obj)))
+            then
+               Search (Constant_Value (Ren_Obj));
+            end if;
+
             return Ren_Obj;
          end Find_Renamed_Object;
 
@@ -8640,11 +8707,6 @@ package body Exp_Util is
 
           and then not Initialized_By_Aliased_BIP_Func_Call (Obj_Id)
 
-          --  Do not consider temporaries created for (class-wide) interface
-          --  objects because they must exist as long as the object is around.
-
-          and then not Is_Temporary_For_Interface_Object (Obj_Id)
-
           --  Do not consider iterators because those are treated as normal
           --  controlled objects and are processed by the usual finalization
           --  machinery. This avoids the double finalization of an iterator.
@@ -9152,24 +9214,6 @@ package body Exp_Util is
         and then Has_Controlling_Result (Id);
    end Is_Secondary_Stack_Thunk;
 
-   ---------------------------------------
-   -- Is_Temporary_For_Interface_Object --
-   ---------------------------------------
-
-   function Is_Temporary_For_Interface_Object
-     (Obj_Id : Entity_Id) return Boolean
-   is
-      Expr : constant Node_Id := Expression (Declaration_Node (Obj_Id));
-
-   begin
-      --  This must be kept synchronized with Expand_N_Object_Declaration
-
-      return Is_Class_Wide_Type (Etype (Obj_Id))
-        and then Present (Expr)
-        and then Nkind (Expr) = N_Unchecked_Type_Conversion
-        and then Is_RTE (Etype (Expression (Expr)), RE_Tag);
-   end Is_Temporary_For_Interface_Object;
-
    --------------------------------
    -- Is_Uninitialized_Aggregate --
    --------------------------------
@@ -9496,67 +9540,13 @@ package body Exp_Util is
       Root_Utyp   : constant Entity_Id  := Underlying_Type (Root_Typ);
       List_Def    : constant List_Id    := Empty_List;
       Comp_List   : constant List_Id    := New_List;
+
       Equiv_Type  : Entity_Id;
       Range_Type  : Entity_Id;
       Str_Type    : Entity_Id;
       Constr_Root : Entity_Id;
+      Size_Attr   : Node_Id;
       Size_Expr   : Node_Id;
-      Size_Pref   : Node_Id;
-
-      function Has_Tag_Of_Type (Exp : Node_Id) return Boolean;
-      --  Return True if expression Exp of a tagged type is known to statically
-      --  have the tag of this tagged type as specified by RM 3.9(19-25).
-
-      ---------------------
-      -- Has_Tag_Of_Type --
-      ---------------------
-
-      function Has_Tag_Of_Type (Exp : Node_Id) return Boolean is
-         Typ : constant Entity_Id := Etype (Exp);
-
-      begin
-         pragma Assert (Is_Tagged_Type (Typ));
-
-         --  The tag of an object of a class-wide type is that of its
-         --  initialization expression.
-
-         if Is_Class_Wide_Type (Typ) then
-            return False;
-         end if;
-
-         --  The tag of a stand-alone object of a specific tagged type T
-         --  identifies T.
-
-         if Is_Entity_Name (Exp)
-           and then Ekind (Entity (Exp)) in E_Constant | E_Variable
-         then
-            return True;
-
-         else
-            case Nkind (E) is
-               --  The tag of a component or an aggregate of a specific tagged
-               --  type T identifies T.
-
-               when N_Indexed_Component
-                 |  N_Selected_Component
-                 |  N_Aggregate
-               =>
-                  return True;
-
-               --  The tag of the result returned by a function whose result
-               --  type is a specific tagged type T identifies T.
-
-               when N_Function_Call =>
-                  return True;
-
-               when N_Explicit_Dereference =>
-                  return Is_Captured_Function_Call (Exp);
-
-               when others =>
-                  return False;
-            end case;
-         end if;
-      end Has_Tag_Of_Type;
 
    begin
       --  If the root type is already constrained, there are no discriminants
@@ -9597,9 +9587,26 @@ package body Exp_Util is
       --  the _Size primitive operation.
 
       if Has_Tag_Of_Type (E) then
-         Size_Pref := Duplicate_Subexpr_No_Checks (E);
+         if not Has_Discriminants (Etype (E))
+           or else Is_Constrained (Etype (E))
+         then
+            Size_Attr :=
+              Make_Attribute_Reference (Loc,
+                Prefix => New_Occurrence_Of (Etype (E), Loc),
+                Attribute_Name => Name_Object_Size);
+
+         else
+            Size_Attr :=
+              Make_Attribute_Reference (Loc,
+                Prefix => Duplicate_Subexpr_No_Checks (E),
+                Attribute_Name => Name_Size);
+         end if;
+
       else
-         Size_Pref := OK_Convert_To (T, Duplicate_Subexpr_No_Checks (E));
+         Size_Attr :=
+           Make_Attribute_Reference (Loc,
+             Prefix => OK_Convert_To (T, Duplicate_Subexpr_No_Checks (E)),
+             Attribute_Name => Name_Size);
       end if;
 
       if not Is_Interface (Root_Typ) then
@@ -9610,10 +9617,7 @@ package body Exp_Util is
 
          Size_Expr :=
            Make_Op_Subtract (Loc,
-             Left_Opnd =>
-               Make_Attribute_Reference (Loc,
-                 Prefix => Size_Pref,
-                 Attribute_Name => Name_Size),
+             Left_Opnd => Size_Attr,
              Right_Opnd =>
                Make_Attribute_Reference (Loc,
                  Prefix => New_Occurrence_Of (Constr_Root, Loc),
@@ -9625,10 +9629,7 @@ package body Exp_Util is
 
          Size_Expr :=
            Make_Op_Subtract (Loc,
-             Left_Opnd =>
-               Make_Attribute_Reference (Loc,
-                 Prefix => Size_Pref,
-                 Attribute_Name => Name_Size),
+             Left_Opnd => Size_Attr,
              Right_Opnd =>
                Make_Attribute_Reference (Loc,
                  Prefix => New_Occurrence_Of (RTE (RE_Tag), Loc),
diff --git a/gcc/ada/exp_util.ads b/gcc/ada/exp_util.ads
index 32f9c24..3dd10d7 100644
--- a/gcc/ada/exp_util.ads
+++ b/gcc/ada/exp_util.ads
@@ -732,6 +732,10 @@ package Exp_Util is
    function Has_Access_Constraint (E : Entity_Id) return Boolean;
    --  Given object or type E, determine if a discriminant is of an access type
 
+   function Has_Tag_Of_Type (Exp : Node_Id) return Boolean;
+   --  Return True if expression Exp of a tagged type is known to statically
+   --  have the tag of this tagged type as specified by RM 3.9(19-25).
+
    function Homonym_Number (Subp : Entity_Id) return Pos;
    --  Here subp is the entity for a subprogram. This routine returns the
    --  homonym number used to disambiguate overloaded subprograms in the same
diff --git a/gcc/ada/gcc-interface/Make-lang.in b/gcc/ada/gcc-interface/Make-lang.in
index c81daae..9507f2f 100644
--- a/gcc/ada/gcc-interface/Make-lang.in
+++ b/gcc/ada/gcc-interface/Make-lang.in
@@ -1,7 +1,5 @@
 # Top level -*- makefile -*- fragment for GNU Ada (GNAT).
-#   Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
-#   2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013
-#   Free Software Foundation, Inc.
+# Copyright (C) 2009-2023 Free Software Foundation, Inc.
 
 #This file is part of GCC.
 
diff --git a/gcc/ada/gcc-interface/Makefile.in b/gcc/ada/gcc-interface/Makefile.in
index 5137eba..da6a56f 100644
--- a/gcc/ada/gcc-interface/Makefile.in
+++ b/gcc/ada/gcc-interface/Makefile.in
@@ -1,5 +1,5 @@
 # Makefile for GNU Ada Compiler (GNAT).
-#   Copyright (C) 1994-2018 Free Software Foundation, Inc.
+#   Copyright (C) 1994-2023 Free Software Foundation, Inc.
 
 #This file is part of GCC.
 
diff --git a/gcc/ada/gcc-interface/ada-builtin-types.def b/gcc/ada/gcc-interface/ada-builtin-types.def
index 000d429..b8925f5 100644
--- a/gcc/ada/gcc-interface/ada-builtin-types.def
+++ b/gcc/ada/gcc-interface/ada-builtin-types.def
@@ -1,7 +1,7 @@
 /* This file contains the type definitions for the builtins exclusively
    used in the GNU Ada compiler.
 
-   Copyright (C) 2019-2022 Free Software Foundation, Inc.
+   Copyright (C) 2019-2023 Free Software Foundation, Inc.
 
 This file is part of GCC.
 
diff --git a/gcc/ada/gcc-interface/ada-builtins.def b/gcc/ada/gcc-interface/ada-builtins.def
index 8ba89a8..cf3d6a1 100644
--- a/gcc/ada/gcc-interface/ada-builtins.def
+++ b/gcc/ada/gcc-interface/ada-builtins.def
@@ -1,7 +1,7 @@
 /* This file contains the definitions for the builtins exclusively used
    in the GNU Ada compiler.
 
-   Copyright (C) 2019-2022 Free Software Foundation, Inc.
+   Copyright (C) 2019-2023 Free Software Foundation, Inc.
 
 This file is part of GCC.
 
diff --git a/gcc/ada/gcc-interface/ada-tree.def b/gcc/ada/gcc-interface/ada-tree.def
index 7fc95cb..ff88e54 100644
--- a/gcc/ada/gcc-interface/ada-tree.def
+++ b/gcc/ada/gcc-interface/ada-tree.def
@@ -6,7 +6,7 @@
  *                                                                          *
  *                              Specification                               *
  *                                                                          *
- *            Copyright (C) 1992-2009, Free Software Foundation, Inc.       *
+ *            Copyright (C) 1992-2023, Free Software Foundation, Inc.       *
  *                                                                          *
  * GNAT is free software;  you can  redistribute it  and/or modify it under *
  * terms of the  GNU General Public License as published  by the Free Soft- *
diff --git a/gcc/ada/gcc-interface/ada-tree.h b/gcc/ada/gcc-interface/ada-tree.h
index 6d9639d..d0acf1d 100644
--- a/gcc/ada/gcc-interface/ada-tree.h
+++ b/gcc/ada/gcc-interface/ada-tree.h
@@ -6,7 +6,7 @@
  *                                                                          *
  *                              C Header File                               *
  *                                                                          *
- *          Copyright (C) 1992-2022, Free Software Foundation, Inc.         *
+ *          Copyright (C) 1992-2023, Free Software Foundation, Inc.         *
  *                                                                          *
  * GNAT is free software;  you can  redistribute it  and/or modify it under *
  * terms of the  GNU General Public License as published  by the Free Soft- *
diff --git a/gcc/ada/gcc-interface/ada.h b/gcc/ada/gcc-interface/ada.h
index d9efb63..45b5bd9 100644
--- a/gcc/ada/gcc-interface/ada.h
+++ b/gcc/ada/gcc-interface/ada.h
@@ -6,7 +6,7 @@
  *                                                                          *
  *                              C Header File                               *
  *                                                                          *
- *          Copyright (C) 1992-2022, Free Software Foundation, Inc.         *
+ *          Copyright (C) 1992-2023, Free Software Foundation, Inc.         *
  *                                                                          *
  * GNAT is free software;  you can  redistribute it  and/or modify it under *
  * terms of the  GNU General Public License as published  by the Free Soft- *
diff --git a/gcc/ada/gcc-interface/config-lang.in b/gcc/ada/gcc-interface/config-lang.in
index 5f72977..85c1f42 100644
--- a/gcc/ada/gcc-interface/config-lang.in
+++ b/gcc/ada/gcc-interface/config-lang.in
@@ -1,5 +1,5 @@
 # Top level configure fragment for GNU Ada (GNAT).
-#   Copyright (C) 1994-2013 Free Software Foundation, Inc.
+#   Copyright (C) 1994-2023 Free Software Foundation, Inc.
 
 #This file is part of GCC.
 
diff --git a/gcc/ada/gcc-interface/cuintp.cc b/gcc/ada/gcc-interface/cuintp.cc
index abf8d46..117d417 100644
--- a/gcc/ada/gcc-interface/cuintp.cc
+++ b/gcc/ada/gcc-interface/cuintp.cc
@@ -6,7 +6,7 @@
  *                                                                          *
  *                          C Implementation File                           *
  *                                                                          *
- *          Copyright (C) 1992-2021, Free Software Foundation, Inc.         *
+ *          Copyright (C) 1992-2023, Free Software Foundation, Inc.         *
  *                                                                          *
  * GNAT is free software;  you can  redistribute it  and/or modify it under *
  * terms of the  GNU General Public License as published  by the Free Soft- *
diff --git a/gcc/ada/gcc-interface/decl.cc b/gcc/ada/gcc-interface/decl.cc
index c383f9b..d24adf3 100644
--- a/gcc/ada/gcc-interface/decl.cc
+++ b/gcc/ada/gcc-interface/decl.cc
@@ -6,7 +6,7 @@
  *                                                                          *
  *                          C Implementation File                           *
  *                                                                          *
- *          Copyright (C) 1992-2022, Free Software Foundation, Inc.         *
+ *          Copyright (C) 1992-2023, Free Software Foundation, Inc.         *
  *                                                                          *
  * GNAT is free software;  you can  redistribute it  and/or modify it under *
  * terms of the  GNU General Public License as published  by the Free Soft- *
diff --git a/gcc/ada/gcc-interface/gadaint.h b/gcc/ada/gcc-interface/gadaint.h
index ac80eeb..5dccab6 100644
--- a/gcc/ada/gcc-interface/gadaint.h
+++ b/gcc/ada/gcc-interface/gadaint.h
@@ -6,7 +6,7 @@
  *                                                                          *
  *                              C Header File                               *
  *                                                                          *
- *           Copyright (C) 2010-2022, Free Software Foundation, Inc.        *
+ *           Copyright (C) 2010-2023, Free Software Foundation, Inc.        *
  *                                                                          *
  * GNAT is free software;  you can  redistribute it  and/or modify it under *
  * terms of the  GNU General Public License as published  by the Free Soft- *
diff --git a/gcc/ada/gcc-interface/gigi.h b/gcc/ada/gcc-interface/gigi.h
index 82e2403..fee0450 100644
--- a/gcc/ada/gcc-interface/gigi.h
+++ b/gcc/ada/gcc-interface/gigi.h
@@ -6,7 +6,7 @@
  *                                                                          *
  *                              C Header File                               *
  *                                                                          *
- *          Copyright (C) 1992-2022, Free Software Foundation, Inc.         *
+ *          Copyright (C) 1992-2023, Free Software Foundation, Inc.         *
  *                                                                          *
  * GNAT is free software;  you can  redistribute it  and/or modify it under *
  * terms of the  GNU General Public License as published  by the Free Soft- *
diff --git a/gcc/ada/gcc-interface/lang-specs.h b/gcc/ada/gcc-interface/lang-specs.h
index 6c260a0..92d311a 100644
--- a/gcc/ada/gcc-interface/lang-specs.h
+++ b/gcc/ada/gcc-interface/lang-specs.h
@@ -6,7 +6,7 @@
  *                                                                          *
  *                              C Header File                               *
  *                                                                          *
- *           Copyright (C) 1992-2022, Free Software Foundation, Inc.        *
+ *           Copyright (C) 1992-2023, Free Software Foundation, Inc.        *
  *                                                                          *
  * GNAT is free software;  you can  redistribute it  and/or modify it under *
  * terms of the  GNU General Public License as published  by the Free Soft- *
diff --git a/gcc/ada/gcc-interface/lang.opt b/gcc/ada/gcc-interface/lang.opt
index 379157c..248bb4c 100644
--- a/gcc/ada/gcc-interface/lang.opt
+++ b/gcc/ada/gcc-interface/lang.opt
@@ -1,5 +1,5 @@
 ; Options for the Ada front end.
-; Copyright (C) 2003-2015 Free Software Foundation, Inc.
+; Copyright (C) 2003-2023 Free Software Foundation, Inc.
 ;
 ; This file is part of GCC.
 ;
diff --git a/gcc/ada/gcc-interface/misc.cc b/gcc/ada/gcc-interface/misc.cc
index e1b5a43..b18ca8c 100644
--- a/gcc/ada/gcc-interface/misc.cc
+++ b/gcc/ada/gcc-interface/misc.cc
@@ -6,7 +6,7 @@
  *                                                                          *
  *                           C Implementation File                          *
  *                                                                          *
- *          Copyright (C) 1992-2021, Free Software Foundation, Inc.         *
+ *          Copyright (C) 1992-2023, Free Software Foundation, Inc.         *
  *                                                                          *
  * GNAT is free software;  you can  redistribute it  and/or modify it under *
  * terms of the  GNU General Public License as published  by the Free Soft- *
diff --git a/gcc/ada/gcc-interface/system.ads b/gcc/ada/gcc-interface/system.ads
index cfd9bb9..5fc8e86 100644
--- a/gcc/ada/gcc-interface/system.ads
+++ b/gcc/ada/gcc-interface/system.ads
@@ -7,7 +7,7 @@
 --                                 S p e c                                  --
 --                            (Compiler Version)                            --
 --                                                                          --
---          Copyright (C) 1992-2021, Free Software Foundation, Inc.         --
+--          Copyright (C) 1992-2023, Free Software Foundation, Inc.         --
 --                                                                          --
 -- This specification is derived from the Ada Reference Manual for use with --
 -- GNAT. The copyright notice above, and the license provisions that follow --
diff --git a/gcc/ada/gcc-interface/targtyps.cc b/gcc/ada/gcc-interface/targtyps.cc
index 84949e3..c3f91c4 100644
--- a/gcc/ada/gcc-interface/targtyps.cc
+++ b/gcc/ada/gcc-interface/targtyps.cc
@@ -6,7 +6,7 @@
  *                                                                          *
  *                          C Implementation File                           *
  *                                                                          *
- *          Copyright (C) 1992-2021, Free Software Foundation, Inc.         *
+ *          Copyright (C) 1992-2023, Free Software Foundation, Inc.         *
  *                                                                          *
  * GNAT is free software;  you can  redistribute it  and/or modify it under *
  * terms of the  GNU General Public License as published  by the Free Soft- *
diff --git a/gcc/ada/gcc-interface/trans.cc b/gcc/ada/gcc-interface/trans.cc
index 6579ad1..28e3867 100644
--- a/gcc/ada/gcc-interface/trans.cc
+++ b/gcc/ada/gcc-interface/trans.cc
@@ -6,7 +6,7 @@
  *                                                                          *
  *                          C Implementation File                           *
  *                                                                          *
- *          Copyright (C) 1992-2022, Free Software Foundation, Inc.         *
+ *          Copyright (C) 1992-2023, Free Software Foundation, Inc.         *
  *                                                                          *
  * GNAT is free software;  you can  redistribute it  and/or modify it under *
  * terms of the  GNU General Public License as published  by the Free Soft- *
diff --git a/gcc/ada/gcc-interface/utils.cc b/gcc/ada/gcc-interface/utils.cc
index 5942de1..392ec0b 100644
--- a/gcc/ada/gcc-interface/utils.cc
+++ b/gcc/ada/gcc-interface/utils.cc
@@ -6,7 +6,7 @@
  *                                                                          *
  *                          C Implementation File                           *
  *                                                                          *
- *          Copyright (C) 1992-2022, Free Software Foundation, Inc.         *
+ *          Copyright (C) 1992-2023, Free Software Foundation, Inc.         *
  *                                                                          *
  * GNAT is free software;  you can  redistribute it  and/or modify it under *
  * terms of the  GNU General Public License as published  by the Free Soft- *
diff --git a/gcc/ada/gcc-interface/utils2.cc b/gcc/ada/gcc-interface/utils2.cc
index 80d550c..6c17675 100644
--- a/gcc/ada/gcc-interface/utils2.cc
+++ b/gcc/ada/gcc-interface/utils2.cc
@@ -6,7 +6,7 @@
  *                                                                          *
  *                          C Implementation File                           *
  *                                                                          *
- *          Copyright (C) 1992-2022, Free Software Foundation, Inc.         *
+ *          Copyright (C) 1992-2023, Free Software Foundation, Inc.         *
  *                                                                          *
  * GNAT is free software;  you can  redistribute it  and/or modify it under *
  * terms of the  GNU General Public License as published  by the Free Soft- *
diff --git a/gcc/analyzer/ChangeLog b/gcc/analyzer/ChangeLog
index 959464a..f8b439e 100644
--- a/gcc/analyzer/ChangeLog
+++ b/gcc/analyzer/ChangeLog
@@ -1,3 +1,65 @@
+2023-01-26  David Malcolm  <dmalcolm@redhat.com>
+
+	PR analyzer/108524
+	* analyzer.h (class feasible_node): New forward decl.
+	* diagnostic-manager.cc (epath_finder::get_best_epath): Add "pd"
+	param.
+	(epath_finder::explore_feasible_paths): Likewise.
+	(epath_finder::process_worklist_item): Likewise.  Use it to call
+	pending_diagnostic::check_valid_fpath_p on the final fpath to
+	give pending_diagnostic a way to add additional restrictions on
+	feasibility.
+	(saved_diagnostic::calc_best_epath): Pass pending_diagnostic to
+	epath_finder::get_best_epath.
+	* infinite-recursion.cc: Include "analyzer/feasible-graph.h".
+	(infinite_recursion_diagnostic::check_valid_fpath_p): New.
+	(infinite_recursion_diagnostic::fedge_uses_conjured_svalue_p): New.
+	(infinite_recursion_diagnostic::expr_uses_conjured_svalue_p): New.
+	* pending-diagnostic.h (pending_diagnostic::check_valid_fpath_p):
+	New vfunc.
+
+2023-01-19  David Malcolm  <dmalcolm@redhat.com>
+
+	PR analyzer/108455
+	* analyzer.h (class checker_event): New forward decl.
+	(class state_change_event): Indent.
+	(class warning_event): New forward decl.
+	* checker-event.cc (state_change_event::state_change_event): Add
+	"enode" param.
+	(warning_event::get_desc): Update for new param of
+	evdesc::final_event ctor.
+	* checker-event.h (state_change_event::state_change_event): Add
+	"enode" param.
+	(state_change_event::get_exploded_node): New accessor.
+	(state_change_event::m_enode): New field.
+	(warning_event::warning_event): New "enode" param.
+	(warning_event::get_exploded_node): New accessor.
+	(warning_event::m_enode): New field.
+	* diagnostic-manager.cc
+	(state_change_event_creator::on_global_state_change): Pass
+	src_node to state_change_event ctor.
+	(state_change_event_creator::on_state_change): Likewise.
+	(null_assignment_sm_context::set_next_state): Pass NULL for
+	new param of state_change_event ctor.
+	* infinite-recursion.cc
+	(infinite_recursion_diagnostic::add_final_event): Update for new
+	param of warning_event ctor.
+	* pending-diagnostic.cc (pending_diagnostic::add_final_event):
+	Pass enode to warning_event ctor.
+	* pending-diagnostic.h (evdesc::final_event): Add reference to
+	warning_event.
+	* sm-malloc.cc: Include "analyzer/checker-event.h" and
+	"analyzer/exploded-graph.h".
+	(deref_before_check::deref_before_check): Initialize new fields.
+	(deref_before_check::emit): Reject warnings in which we were
+	unable to determine the enodes of the dereference and the check.
+	Reject warnings interprocedural warnings. Reject warnings in which
+	the dereference doesn't dominate the check.
+	(deref_before_check::describe_state_change): Set m_deref_enode.
+	(deref_before_check::describe_final_event): Set m_check_enode.
+	(deref_before_check::m_deref_enode): New field.
+	(deref_before_check::m_check_enode): New field.
+
 2023-01-13  David Malcolm  <dmalcolm@redhat.com>
 
 	PR analyzer/105273
diff --git a/gcc/analyzer/analyzer.h b/gcc/analyzer/analyzer.h
index bfd098b..a161952 100644
--- a/gcc/analyzer/analyzer.h
+++ b/gcc/analyzer/analyzer.h
@@ -93,7 +93,9 @@ class bounded_ranges_manager;
 class pending_diagnostic;
 class pending_note;
 struct event_loc_info;
-class state_change_event;
+class checker_event;
+  class state_change_event;
+  class warning_event;
 class checker_path;
 class extrinsic_state;
 class sm_state_map;
@@ -124,6 +126,8 @@ class call_summary_replay;
 struct per_function_data;
 struct interesting_t;
 
+class feasible_node;
+
 /* Forward decls of functions.  */
 
 extern void dump_tree (pretty_printer *pp, tree t);
diff --git a/gcc/analyzer/checker-event.cc b/gcc/analyzer/checker-event.cc
index b0128e5..3612df7 100644
--- a/gcc/analyzer/checker-event.cc
+++ b/gcc/analyzer/checker-event.cc
@@ -410,7 +410,8 @@ state_change_event::state_change_event (const supernode *node,
 					state_machine::state_t from,
 					state_machine::state_t to,
 					const svalue *origin,
-					const program_state &dst_state)
+					const program_state &dst_state,
+					const exploded_node *enode)
 : checker_event (EK_STATE_CHANGE,
 		 event_loc_info (stmt->location,
 				 node->m_fun->decl,
@@ -418,7 +419,8 @@ state_change_event::state_change_event (const supernode *node,
   m_node (node), m_stmt (stmt), m_sm (sm),
   m_sval (sval), m_from (from), m_to (to),
   m_origin (origin),
-  m_dst_state (dst_state)
+  m_dst_state (dst_state),
+  m_enode (enode)
 {
 }
 
@@ -1159,7 +1161,7 @@ warning_event::get_desc (bool can_colorize) const
       tree var = fixup_tree_for_diagnostic (m_var);
       label_text ev_desc
 	= m_pending_diagnostic->describe_final_event
-	    (evdesc::final_event (can_colorize, var, m_state));
+	    (evdesc::final_event (can_colorize, var, m_state, *this));
       if (ev_desc.get ())
 	{
 	  if (m_sm && flag_analyzer_verbose_state_changes)
diff --git a/gcc/analyzer/checker-event.h b/gcc/analyzer/checker-event.h
index 429d4cb..5dd25cb 100644
--- a/gcc/analyzer/checker-event.h
+++ b/gcc/analyzer/checker-event.h
@@ -357,7 +357,8 @@ public:
 		      state_machine::state_t from,
 		      state_machine::state_t to,
 		      const svalue *origin,
-		      const program_state &dst_state);
+		      const program_state &dst_state,
+		      const exploded_node *enode);
 
   label_text get_desc (bool can_colorize) const final override;
   meaning get_meaning () const override;
@@ -367,6 +368,8 @@ public:
     return m_dst_state.get_current_function ();
   }
 
+  const exploded_node *get_exploded_node () const { return m_enode; }
+
   const supernode *m_node;
   const gimple *m_stmt;
   const state_machine &m_sm;
@@ -375,6 +378,7 @@ public:
   state_machine::state_t m_to;
   const svalue *m_origin;
   program_state m_dst_state;
+  const exploded_node *m_enode;
 };
 
 /* Subclass of checker_event; parent class for subclasses that relate to
@@ -668,9 +672,11 @@ class warning_event : public checker_event
 {
 public:
   warning_event (const event_loc_info &loc_info,
+		 const exploded_node *enode,
 		 const state_machine *sm,
 		 tree var, state_machine::state_t state)
   : checker_event (EK_WARNING, loc_info),
+    m_enode (enode),
     m_sm (sm), m_var (var), m_state (state)
   {
   }
@@ -678,7 +684,10 @@ public:
   label_text get_desc (bool can_colorize) const final override;
   meaning get_meaning () const override;
 
+  const exploded_node *get_exploded_node () const { return m_enode; }
+
 private:
+  const exploded_node *m_enode;
   const state_machine *m_sm;
   tree m_var;
   state_machine::state_t m_state;
diff --git a/gcc/analyzer/diagnostic-manager.cc b/gcc/analyzer/diagnostic-manager.cc
index f4d3561..4f036a6 100644
--- a/gcc/analyzer/diagnostic-manager.cc
+++ b/gcc/analyzer/diagnostic-manager.cc
@@ -88,6 +88,7 @@ public:
 
   std::unique_ptr<exploded_path>
   get_best_epath (const exploded_node *target_enode,
+		  const pending_diagnostic &pd,
 		  const char *desc, unsigned diag_idx,
 		  std::unique_ptr<feasibility_problem> *out_problem);
 
@@ -96,12 +97,14 @@ private:
 
   std::unique_ptr<exploded_path>
   explore_feasible_paths (const exploded_node *target_enode,
+			  const pending_diagnostic &pd,
 			  const char *desc, unsigned diag_idx);
   bool
   process_worklist_item (feasible_worklist *worklist,
 			 const trimmed_graph &tg,
 			 feasible_graph *fg,
 			 const exploded_node *target_enode,
+			 const pending_diagnostic &pd,
 			 unsigned diag_idx,
 			 std::unique_ptr<exploded_path> *out_best_path) const;
   void dump_trimmed_graph (const exploded_node *target_enode,
@@ -138,6 +141,7 @@ private:
 
 std::unique_ptr<exploded_path>
 epath_finder::get_best_epath (const exploded_node *enode,
+			      const pending_diagnostic &pd,
 			      const char *desc, unsigned diag_idx,
 			      std::unique_ptr<feasibility_problem> *out_problem)
 {
@@ -161,7 +165,7 @@ epath_finder::get_best_epath (const exploded_node *enode,
       if (logger)
 	logger->log ("trying to find shortest feasible path");
       if (std::unique_ptr<exploded_path> epath
-	    = explore_feasible_paths (enode, desc, diag_idx))
+	    = explore_feasible_paths (enode, pd, desc, diag_idx))
 	{
 	  if (logger)
 	    logger->log ("accepting %qs at EN: %i, SN: %i (sd: %i)"
@@ -374,6 +378,7 @@ private:
 
 std::unique_ptr<exploded_path>
 epath_finder::explore_feasible_paths (const exploded_node *target_enode,
+				      const pending_diagnostic &pd,
 				      const char *desc, unsigned diag_idx)
 {
   logger *logger = get_logger ();
@@ -415,8 +420,8 @@ epath_finder::explore_feasible_paths (const exploded_node *target_enode,
   {
     auto_checking_feasibility sentinel (mgr);
 
-    while (process_worklist_item (&worklist, tg, &fg, target_enode, diag_idx,
-				  &best_path))
+    while (process_worklist_item (&worklist, tg, &fg, target_enode, pd,
+				  diag_idx, &best_path))
       {
 	/* Empty; the work is done within process_worklist_item.  */
       }
@@ -449,7 +454,10 @@ epath_finder::explore_feasible_paths (const exploded_node *target_enode,
    Return false if the processing of the worklist should stop
    (either due to reaching TARGET_ENODE, or hitting a limit).
    Write to *OUT_BEST_PATH if stopping due to finding a feasible path
-   to TARGET_ENODE.  */
+   to TARGET_ENODE.
+   Use PD to provide additional restrictions on feasibility of
+   the final path in the feasible_graph before converting to
+   an exploded_path.  */
 
 bool
 epath_finder::
@@ -457,6 +465,7 @@ process_worklist_item (feasible_worklist *worklist,
 		       const trimmed_graph &tg,
 		       feasible_graph *fg,
 		       const exploded_node *target_enode,
+		       const pending_diagnostic &pd,
 		       unsigned diag_idx,
 		       std::unique_ptr<exploded_path> *out_best_path) const
 {
@@ -514,6 +523,13 @@ process_worklist_item (feasible_worklist *worklist,
 			     " (length: %i)",
 			     target_enode->m_index, diag_idx,
 			     succ_fnode->get_path_length ());
+	      if (!pd.check_valid_fpath_p (succ_fnode))
+		{
+		  if (logger)
+		    logger->log ("rejecting feasible path due to"
+				 " pending_diagnostic");
+		  return false;
+		}
 	      *out_best_path = fg->make_epath (succ_fnode);
 	      if (flag_dump_analyzer_feasibility)
 		dump_feasible_path (target_enode, diag_idx, *fg, *succ_fnode);
@@ -808,7 +824,7 @@ saved_diagnostic::calc_best_epath (epath_finder *pf)
   LOG_SCOPE (logger);
   m_problem = NULL;
 
-  m_best_epath = pf->get_best_epath (m_enode, m_d->get_kind (), m_idx,
+  m_best_epath = pf->get_best_epath (m_enode, *m_d, m_d->get_kind (), m_idx,
 				     &m_problem);
 
   /* Handle failure to find a feasible path.  */
@@ -1572,7 +1588,8 @@ public:
 					src_sm_val,
 					dst_sm_val,
 					NULL,
-					dst_state));
+					dst_state,
+					src_node));
     return false;
   }
 
@@ -1616,7 +1633,8 @@ public:
 					src_sm_val,
 					dst_sm_val,
 					dst_origin_sval,
-					dst_state));
+					dst_state,
+					src_node));
     return false;
   }
 
@@ -1760,7 +1778,8 @@ struct null_assignment_sm_context : public sm_context
 					var_new_sval,
 					from, to,
 					NULL,
-					*m_new_state));
+					*m_new_state,
+					NULL));
   }
 
   void set_next_state (const gimple *stmt,
@@ -1785,7 +1804,8 @@ struct null_assignment_sm_context : public sm_context
 					sval,
 					from, to,
 					NULL,
-					*m_new_state));
+					*m_new_state,
+					NULL));
   }
 
   void warn (const supernode *, const gimple *,
diff --git a/gcc/analyzer/infinite-recursion.cc b/gcc/analyzer/infinite-recursion.cc
index a49ad2d..8d101d1 100644
--- a/gcc/analyzer/infinite-recursion.cc
+++ b/gcc/analyzer/infinite-recursion.cc
@@ -62,6 +62,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "analyzer/exploded-graph.h"
 #include "make-unique.h"
 #include "analyzer/checker-path.h"
+#include "analyzer/feasible-graph.h"
 
 /* A subclass of pending_diagnostic for complaining about suspected
    infinite recursion.  */
@@ -182,7 +183,7 @@ public:
   /* Customize the location where the warning_event appears, putting
      it at the topmost entrypoint to the function.  */
   void add_final_event (const state_machine *,
-			const exploded_node *,
+			const exploded_node *enode,
 			const gimple *,
 			tree,
 			state_machine::state_t,
@@ -195,10 +196,110 @@ public:
 			  ()->get_start_location (),
 			m_callee_fndecl,
 			m_new_entry_enode->get_stack_depth ()),
+	enode,
 	NULL, NULL, NULL));
   }
 
+  /* Reject paths in which conjured svalues have affected control flow
+     since m_prev_entry_enode.  */
+
+  bool check_valid_fpath_p (const feasible_node *final_fnode)
+    const final override
+  {
+    /* Reject paths in which calls with unknown side effects have occurred
+       since m_prev_entry_enode.
+       Find num calls with side effects.  Walk backward until we reach the
+       pref */
+    gcc_assert (final_fnode->get_inner_node () == m_new_entry_enode);
+
+    /* FG is actually a tree.  Walk backwards from FINAL_FNODE until we
+       reach the prev_entry_enode (or the origin).  */
+    const feasible_node *iter_fnode = final_fnode;
+    while (iter_fnode->get_inner_node ()->m_index != 0)
+      {
+	gcc_assert (iter_fnode->m_preds.length () == 1);
+
+	feasible_edge *pred_fedge
+	  = static_cast <feasible_edge *> (iter_fnode->m_preds[0]);
+
+	/* Determine if conjured svalues have affected control flow
+	   since the prev entry node.  */
+	if (fedge_uses_conjured_svalue_p (pred_fedge))
+	  /* If so, then reject this diagnostic.  */
+	  return false;
+	iter_fnode = static_cast <feasible_node *> (pred_fedge->m_src);
+	if (iter_fnode->get_inner_node () == m_prev_entry_enode)
+	  /* Accept this diagnostic.  */
+	  return true;
+    }
+
+    /* We shouldn't get here; if we do, reject the diagnostic.  */
+    gcc_unreachable ();
+    return false;
+  }
+
 private:
+  /* Return true iff control flow along FEDGE was affected by
+     a conjured_svalue.  */
+  static bool fedge_uses_conjured_svalue_p (feasible_edge *fedge)
+  {
+    const exploded_edge *eedge = fedge->get_inner_edge ();
+    const superedge *sedge = eedge->m_sedge;
+    if (!sedge)
+      return false;
+    const cfg_superedge *cfg_sedge = sedge->dyn_cast_cfg_superedge ();
+    if (!cfg_sedge)
+      return false;
+    const gimple *last_stmt = sedge->m_src->get_last_stmt ();
+    if (!last_stmt)
+      return false;
+
+    const feasible_node *dst_fnode
+      = static_cast<const feasible_node *> (fedge->m_dest);
+    const region_model &model = dst_fnode->get_state ().get_model ();
+
+    if (const gcond *cond_stmt = dyn_cast <const gcond *> (last_stmt))
+      {
+	if (expr_uses_conjured_svalue_p (model, gimple_cond_lhs (cond_stmt)))
+	  return true;
+	if (expr_uses_conjured_svalue_p (model, gimple_cond_rhs (cond_stmt)))
+	  return true;
+      }
+    else if (const gswitch *switch_stmt
+	       = dyn_cast <const gswitch *> (last_stmt))
+      {
+	if (expr_uses_conjured_svalue_p (model,
+					 gimple_switch_index (switch_stmt)))
+	  return true;
+      }
+    return false;
+  }
+
+  /* Return true iff EXPR is affected by a conjured_svalue.  */
+  static bool expr_uses_conjured_svalue_p (const region_model &model,
+					   tree expr)
+  {
+    class conjured_svalue_finder : public visitor
+    {
+    public:
+      conjured_svalue_finder () : m_found_conjured_svalues (false)
+      {
+      }
+      void
+      visit_conjured_svalue (const conjured_svalue *) final override
+      {
+	m_found_conjured_svalues = true;
+      }
+
+      bool m_found_conjured_svalues;
+    };
+
+    const svalue *sval = model.get_rvalue (expr, NULL);
+    conjured_svalue_finder v;
+    sval->accept (&v);
+    return v.m_found_conjured_svalues;
+  }
+
   const exploded_node *m_prev_entry_enode;
   const exploded_node *m_new_entry_enode;
   tree m_callee_fndecl;
diff --git a/gcc/analyzer/pending-diagnostic.cc b/gcc/analyzer/pending-diagnostic.cc
index c5a0e9c..79e6c55 100644
--- a/gcc/analyzer/pending-diagnostic.cc
+++ b/gcc/analyzer/pending-diagnostic.cc
@@ -232,6 +232,7 @@ pending_diagnostic::add_final_event (const state_machine *sm,
      (event_loc_info (get_stmt_location (stmt, enode->get_function ()),
 		      enode->get_function ()->decl,
 		      enode->get_stack_depth ()),
+      enode,
       sm, var, state));
 }
 
diff --git a/gcc/analyzer/pending-diagnostic.h b/gcc/analyzer/pending-diagnostic.h
index 6016bf6..b919d5b 100644
--- a/gcc/analyzer/pending-diagnostic.h
+++ b/gcc/analyzer/pending-diagnostic.h
@@ -131,13 +131,15 @@ struct return_of_state : public event_desc
 struct final_event : public event_desc
 {
   final_event (bool colorize,
-	       tree expr, state_machine::state_t state)
+	       tree expr, state_machine::state_t state,
+	       const warning_event &event)
   : event_desc (colorize),
-    m_expr (expr), m_state (state)
+    m_expr (expr), m_state (state), m_event (event)
   {}
 
   tree m_expr;
   state_machine::state_t m_state;
+  const warning_event &m_event;
 };
 
 } /* end of namespace evdesc */
@@ -345,6 +347,15 @@ class pending_diagnostic
   {
     /* Default no-op implementation.  */
   }
+
+  /* Vfunc to give diagnostic subclasses the opportunity to reject diagnostics
+     by imposing their own additional feasibility checks on the path to a
+     given feasible_node.  */
+  virtual bool check_valid_fpath_p (const feasible_node *) const
+  {
+    /* Default implementation: accept this path.  */
+    return true;
+  }
 };
 
 /* A template to make it easier to make subclasses of pending_diagnostic.
diff --git a/gcc/analyzer/sm-malloc.cc b/gcc/analyzer/sm-malloc.cc
index 212e9c2..9aee810 100644
--- a/gcc/analyzer/sm-malloc.cc
+++ b/gcc/analyzer/sm-malloc.cc
@@ -45,6 +45,8 @@ along with GCC; see the file COPYING3.  If not see
 #include "attribs.h"
 #include "analyzer/function-set.h"
 #include "analyzer/program-state.h"
+#include "analyzer/checker-event.h"
+#include "analyzer/exploded-graph.h"
 
 #if ENABLE_ANALYZER
 
@@ -1490,7 +1492,9 @@ class deref_before_check : public malloc_diagnostic
 {
 public:
   deref_before_check (const malloc_state_machine &sm, tree arg)
-  : malloc_diagnostic (sm, arg)
+  : malloc_diagnostic (sm, arg),
+    m_deref_enode (NULL),
+    m_check_enode (NULL)
   {}
 
   const char *get_kind () const final override { return "deref_before_check"; }
@@ -1502,6 +1506,31 @@ public:
 
   bool emit (rich_location *rich_loc) final override
   {
+    /* Don't emit the warning if we can't show where the deref
+       and the check occur.  */
+    if (!m_deref_enode)
+      return false;
+    if (!m_check_enode)
+      return false;
+    /* Only emit the warning for intraprocedural cases.  */
+    if (m_deref_enode->get_function () != m_check_enode->get_function ())
+      return false;
+    if (&m_deref_enode->get_point ().get_call_string ()
+	!= &m_check_enode->get_point ().get_call_string ())
+      return false;
+
+    /* Reject the warning if the deref's BB doesn't dominate that
+       of the check, so that we don't warn e.g. for shared cleanup
+       code that checks a pointer for NULL, when that code is sometimes
+       used before a deref and sometimes after.
+       Using the dominance code requires setting cfun.  */
+    auto_cfun sentinel (m_deref_enode->get_function ());
+    calculate_dominance_info (CDI_DOMINATORS);
+    if (!dominated_by_p (CDI_DOMINATORS,
+			 m_check_enode->get_supernode ()->m_bb,
+			 m_deref_enode->get_supernode ()->m_bb))
+      return false;
+
     if (m_arg)
       return warning_at (rich_loc, get_controlling_option (),
 			 "check of %qE for NULL after already"
@@ -1520,6 +1549,7 @@ public:
 	&& assumed_non_null_p (change.m_new_state))
       {
 	m_first_deref_event = change.m_event_id;
+	m_deref_enode = change.m_event.get_exploded_node ();
 	if (m_arg)
 	  return change.formatted_print ("pointer %qE is dereferenced here",
 					 m_arg);
@@ -1531,6 +1561,7 @@ public:
 
   label_text describe_final_event (const evdesc::final_event &ev) final override
   {
+    m_check_enode = ev.m_event.get_exploded_node ();
     if (m_first_deref_event.known_p ())
       {
 	if (m_arg)
@@ -1556,6 +1587,8 @@ public:
 
 private:
   diagnostic_event_id_t m_first_deref_event;
+  const exploded_node *m_deref_enode;
+  const exploded_node *m_check_enode;
 };
 
 /* struct allocation_state : public state_machine::state.  */
diff --git a/gcc/bb-reorder.cc b/gcc/bb-reorder.cc
index 6f60642..615d542 100644
--- a/gcc/bb-reorder.cc
+++ b/gcc/bb-reorder.cc
@@ -1998,6 +1998,7 @@ fix_up_fall_thru_edges (void)
 		     becomes EDGE_CROSSING.  */
 
 		  fall_thru->flags &= ~EDGE_CROSSING;
+		  unsigned old_count = EDGE_COUNT (cur_bb->succs);
 		  basic_block new_bb = force_nonfallthru (fall_thru);
 
 		  if (new_bb)
@@ -2009,7 +2010,25 @@ fix_up_fall_thru_edges (void)
 		      gcc_assert (BB_PARTITION (new_bb)
                                   == BB_PARTITION (cur_bb));
 
-		      single_succ_edge (new_bb)->flags |= EDGE_CROSSING;
+		      edge e = single_succ_edge (new_bb);
+		      e->flags |= EDGE_CROSSING;
+		      if (EDGE_COUNT (cur_bb->succs) > old_count)
+			{
+			  /* If asm goto has a crossing fallthrough edge
+			     and at least one of the labels to the same bb,
+			     force_nonfallthru can result in the fallthrough
+			     edge being redirected and a new edge added for the
+			     label or more labels to e->dest.  As we've
+			     temporarily cleared EDGE_CROSSING flag on the
+			     fallthrough edge, we need to restore it again.
+			     See PR108596.  */
+			  rtx_insn *j = BB_END (cur_bb);
+			  gcc_checking_assert (JUMP_P (j)
+					       && asm_noperands (PATTERN (j)));
+			  edge e2 = find_edge (cur_bb, e->dest);
+			  if (e2)
+			    e2->flags |= EDGE_CROSSING;
+			}
 		    }
 		  else
 		    {
diff --git a/gcc/c-family/ChangeLog b/gcc/c-family/ChangeLog
index 2e8804a..76b7503 100644
--- a/gcc/c-family/ChangeLog
+++ b/gcc/c-family/ChangeLog
@@ -1,3 +1,13 @@
+2023-01-26  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/105300
+	* c-pragma.cc (handle_pragma_message): Warn for CPP_STRING_USERDEF.
+
+2023-01-18  Marek Polacek  <polacek@redhat.com>
+
+	PR c/108424
+	* c-common.cc (check_case_value): Check INTEGRAL_TYPE_P.
+
 2023-01-14  Jakub Jelinek  <jakub@redhat.com>
 
 	PR c++/108365
diff --git a/gcc/c-family/c-common.cc b/gcc/c-family/c-common.cc
index 76c8abe..ae92cd5 100644
--- a/gcc/c-family/c-common.cc
+++ b/gcc/c-family/c-common.cc
@@ -2238,7 +2238,8 @@ check_case_value (location_t loc, tree value)
   if (value == NULL_TREE)
     return value;
 
-  if (TREE_CODE (value) == INTEGER_CST)
+  if (INTEGRAL_TYPE_P (TREE_TYPE (value))
+      && TREE_CODE (value) == INTEGER_CST)
     /* Promote char or short to int.  */
     value = perform_integral_promotions (value);
   else if (value != error_mark_node)
diff --git a/gcc/c-family/c-pragma.cc b/gcc/c-family/c-pragma.cc
index 68d1c8b..0d2b333 100644
--- a/gcc/c-family/c-pragma.cc
+++ b/gcc/c-family/c-pragma.cc
@@ -1390,6 +1390,9 @@ handle_pragma_message (cpp_reader *)
     }
   else if (token == CPP_STRING)
     message = x;
+  else if (token == CPP_STRING_USERDEF)
+    GCC_BAD ("string literal with user-defined suffix is invalid in this "
+	     "context");
   else
     GCC_BAD ("expected a string after %<#pragma message%>");
 
diff --git a/gcc/c/ChangeLog b/gcc/c/ChangeLog
index 0a10d16..fd1b72f 100644
--- a/gcc/c/ChangeLog
+++ b/gcc/c/ChangeLog
@@ -1,3 +1,15 @@
+2023-01-27  Joseph Myers  <joseph@codesourcery.com>
+
+	* c-parser.cc (c_parser_declaration_or_fndef): Do not allow braces
+	around auto initializer.
+
+2023-01-16  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/105593
+	* c-parser.cc (c_parser_initializer): Check warning_enabled_at
+	at the DECL_SOURCE_LOCATION (decl) for OPT_Winit_self instead
+	of warn_init_self.
+
 2023-01-14  Jakub Jelinek  <jakub@redhat.com>
 
 	PR c++/108365
diff --git a/gcc/c/c-parser.cc b/gcc/c/c-parser.cc
index 803b04b..6923000 100644
--- a/gcc/c/c-parser.cc
+++ b/gcc/c/c-parser.cc
@@ -2480,18 +2480,7 @@ c_parser_declaration_or_fndef (c_parser *parser, bool fndef_ok,
 		  int flag_sanitize_save = flag_sanitize;
 		  if (nested && !empty_ok)
 		    flag_sanitize = 0;
-		  if (std_auto_type_p
-		      && c_parser_next_token_is (parser, CPP_OPEN_BRACE))
-		    {
-		      matching_braces braces;
-		      braces.consume_open (parser);
-		      init = c_parser_expr_no_commas (parser, NULL);
-		      if (c_parser_next_token_is (parser, CPP_COMMA))
-			c_parser_consume_token (parser);
-		      braces.skip_until_found_close (parser);
-		    }
-		  else
-		    init = c_parser_expr_no_commas (parser, NULL);
+		  init = c_parser_expr_no_commas (parser, NULL);
 		  if (std_auto_type_p)
 		    finish_underspecified_init (underspec_name,
 						underspec_state);
diff --git a/gcc/cgraph.cc b/gcc/cgraph.cc
index 5e60c2b..06bc980 100644
--- a/gcc/cgraph.cc
+++ b/gcc/cgraph.cc
@@ -1893,8 +1893,18 @@ cgraph_node::remove (void)
   else if (clone_of)
     {
       clone_of->clones = next_sibling_clone;
-      if (!clone_of->analyzed && !clone_of->clones && !clones)
-	clone_of->release_body ();
+      if (!clones)
+	{
+	  bool need_body = false;
+	  for (cgraph_node *n = clone_of; n; n = n->clone_of)
+	    if (n->analyzed || n->clones)
+	      {
+		need_body = true;
+		break;
+	      }
+	  if (!need_body)
+	    clone_of->release_body ();
+	}
     }
   if (next_sibling_clone)
     next_sibling_clone->prev_sibling_clone = prev_sibling_clone;
@@ -3238,9 +3248,11 @@ cgraph_edge::verify_corresponds_to_fndecl (tree decl)
   node = node->ultimate_alias_target ();
 
   /* Optimizers can redirect unreachable calls or calls triggering undefined
-     behavior to builtin_unreachable.  */
+     behavior to __builtin_unreachable or __builtin_trap.  */
 
-  if (fndecl_built_in_p (callee->decl, BUILT_IN_UNREACHABLE))
+  if (fndecl_built_in_p (callee->decl, BUILT_IN_NORMAL)
+      && (DECL_FUNCTION_CODE (callee->decl) == BUILT_IN_UNREACHABLE
+	  || DECL_FUNCTION_CODE (callee->decl) == BUILT_IN_TRAP))
     return false;
 
   if (callee->former_clone_of != node->decl
@@ -4171,7 +4183,7 @@ cgraph_edge::possibly_call_in_translation_unit_p (void)
     node = node->previous_sharing_asm_name;
   if (node->previous_sharing_asm_name)
     node = symtab_node::get_for_asmname (DECL_ASSEMBLER_NAME (callee->decl));
-  gcc_assert (TREE_PUBLIC (node->decl));
+  gcc_assert (TREE_PUBLIC (node->decl) || DECL_EXTERNAL (node->decl));
   return node->get_availability () >= AVAIL_INTERPOSABLE;
 }
 
diff --git a/gcc/cgraphbuild.cc b/gcc/cgraphbuild.cc
index f13abca..597831e 100644
--- a/gcc/cgraphbuild.cc
+++ b/gcc/cgraphbuild.cc
@@ -31,6 +31,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "gimple-walk.h"
 #include "ipa-utils.h"
 #include "except.h"
+#include "gimplify.h"
 
 /* Context of record_reference.  */
 struct record_reference_ctx
@@ -79,6 +80,17 @@ record_reference (tree *tp, int *walk_subtrees, void *data)
 
       if (VAR_P (decl))
 	{
+	  /* Replace vars with their DECL_VALUE_EXPR if any.
+	     This is normally done during gimplification, but
+	     static var initializers are never gimplified.  */
+	  if (DECL_HAS_VALUE_EXPR_P (decl))
+	    {
+	      tree *p;
+	      for (p = tp; *p != decl; p = &TREE_OPERAND (*p, 0))
+		;
+	      *p = unshare_expr (DECL_VALUE_EXPR (decl));
+	      return record_reference (tp, walk_subtrees, data);
+	    }
 	  varpool_node *vnode = varpool_node::get_create (decl);
 	  ctx->varpool_node->create_reference (vnode, IPA_REF_ADDR);
 	}
diff --git a/gcc/cgraphunit.cc b/gcc/cgraphunit.cc
index 59ce270..832818d 100644
--- a/gcc/cgraphunit.cc
+++ b/gcc/cgraphunit.cc
@@ -1087,8 +1087,6 @@ check_global_declaration (symtab_node *snode)
       else
 	warning (OPT_Wunused_function, "%q+F declared %<static%> but never "
 				       "defined", decl);
-      /* This symbol is effectively an "extern" declaration now.  */
-      TREE_PUBLIC (decl) = 1;
     }
 
   /* Warn about static fns or vars defined but not used.  */
diff --git a/gcc/common/config/aarch64/aarch64-common.cc b/gcc/common/config/aarch64/aarch64-common.cc
index a9695d6..5fb9e9d 100644
--- a/gcc/common/config/aarch64/aarch64-common.cc
+++ b/gcc/common/config/aarch64/aarch64-common.cc
@@ -31,6 +31,7 @@
 #include "flags.h"
 #include "diagnostic.h"
 #include "config/aarch64/aarch64-feature-deps.h"
+#include "config/arm/aarch-common.h"
 
 #ifdef  TARGET_BIG_ENDIAN_DEFAULT
 #undef  TARGET_DEFAULT_TARGET_FLAGS
@@ -191,13 +192,13 @@ static constexpr arch_to_arch_name all_architectures[] =
 
 /* Parse the architecture extension string STR and update ISA_FLAGS
    with the architecture features turned on or off.  Return a
-   aarch64_parse_opt_result describing the result.
+   aarch_parse_opt_result describing the result.
    When the STR string contains an invalid extension,
    a copy of the string is created and stored to INVALID_EXTENSION.  */
 
-enum aarch64_parse_opt_result
+enum aarch_parse_opt_result
 aarch64_parse_extension (const char *str, aarch64_feature_flags *isa_flags,
-			 std::string *invalid_extension)
+                         std::string *invalid_extension)
 {
   /* The extension string is parsed left to right.  */
   const struct aarch64_option_extension *opt = NULL;
@@ -228,7 +229,7 @@ aarch64_parse_extension (const char *str, aarch64_feature_flags *isa_flags,
 	adding_ext = 1;
 
       if (len == 0)
-	return AARCH64_PARSE_MISSING_ARG;
+	return AARCH_PARSE_MISSING_ARG;
 
 
       /* Scan over the extensions table trying to find an exact match.  */
@@ -250,13 +251,13 @@ aarch64_parse_extension (const char *str, aarch64_feature_flags *isa_flags,
 	  /* Extension not found in list.  */
 	  if (invalid_extension)
 	    *invalid_extension = std::string (str, len);
-	  return AARCH64_PARSE_INVALID_FEATURE;
+	  return AARCH_PARSE_INVALID_FEATURE;
 	}
 
       str = ext;
     };
 
-  return AARCH64_PARSE_OK;
+  return AARCH_PARSE_OK;
 }
 
 /* Append all architecture extension candidates to the CANDIDATES vector.  */
diff --git a/gcc/common/config/riscv/riscv-common.cc b/gcc/common/config/riscv/riscv-common.cc
index 2e3116e..616e2f8 100644
--- a/gcc/common/config/riscv/riscv-common.cc
+++ b/gcc/common/config/riscv/riscv-common.cc
@@ -1756,6 +1756,10 @@ static const struct default_options riscv_option_optimization_table[] =
   {
     { OPT_LEVELS_1_PLUS, OPT_fsection_anchors, NULL, 1 },
     { OPT_LEVELS_2_PLUS, OPT_free, NULL, 1 },
+#if TARGET_DEFAULT_ASYNC_UNWIND_TABLES == 1
+    { OPT_LEVELS_ALL, OPT_fasynchronous_unwind_tables, NULL, 1 },
+    { OPT_LEVELS_ALL, OPT_funwind_tables, NULL, 1},
+#endif
     { OPT_LEVELS_NONE, 0, NULL, 0 }
   };
 
diff --git a/gcc/config.gcc b/gcc/config.gcc
index 3827b2f..217338e 100644
--- a/gcc/config.gcc
+++ b/gcc/config.gcc
@@ -349,7 +349,7 @@ aarch64*-*-*)
 	c_target_objs="aarch64-c.o"
 	cxx_target_objs="aarch64-c.o"
 	d_target_objs="aarch64-d.o"
-	extra_objs="aarch64-builtins.o aarch-common.o aarch64-sve-builtins.o aarch64-sve-builtins-shapes.o aarch64-sve-builtins-base.o aarch64-sve-builtins-sve2.o cortex-a57-fma-steering.o aarch64-speculation.o falkor-tag-collision-avoidance.o aarch64-bti-insert.o aarch64-cc-fusion.o"
+	extra_objs="aarch64-builtins.o aarch-common.o aarch64-sve-builtins.o aarch64-sve-builtins-shapes.o aarch64-sve-builtins-base.o aarch64-sve-builtins-sve2.o cortex-a57-fma-steering.o aarch64-speculation.o falkor-tag-collision-avoidance.o aarch-bti-insert.o aarch64-cc-fusion.o"
 	target_gtfiles="\$(srcdir)/config/aarch64/aarch64-builtins.cc \$(srcdir)/config/aarch64/aarch64-sve-builtins.h \$(srcdir)/config/aarch64/aarch64-sve-builtins.cc"
 	target_has_targetm_common=yes
 	;;
@@ -373,7 +373,7 @@ arc*-*-*)
 	;;
 arm*-*-*)
 	cpu_type=arm
-	extra_objs="arm-builtins.o arm-mve-builtins.o aarch-common.o"
+	extra_objs="arm-builtins.o arm-mve-builtins.o aarch-common.o aarch-bti-insert.o"
 	extra_headers="mmintrin.h arm_neon.h arm_acle.h arm_fp16.h arm_cmse.h arm_bf16.h arm_mve_types.h arm_mve.h arm_cde.h"
 	target_type_format_char='%'
 	c_target_objs="arm-c.o"
@@ -1683,7 +1683,12 @@ csky-*-*)
 		;;
 	    csky-*-linux*)
 		tm_file="elfos.h gnu-user.h linux.h glibc-stdint.h ${tm_file} csky/csky-linux-elf.h"
-		tmake_file="${tmake_file} csky/t-csky csky/t-csky-linux"
+		tmake_file="${tmake_file} csky/t-csky"
+
+		if test "x${enable_multilib}" = xyes ; then
+		    tm_defines="$tm_defines CSKY_ENABLE_MULTILIB"
+		    tmake_file="${tmake_file} csky/t-csky-linux"
+		fi
 
 		case ${target} in
 		    csky-*-linux-gnu*)
@@ -2007,7 +2012,7 @@ i[34567]86-*-linux* | i[34567]86-*-kfreebsd*-gnu | i[34567]86-*-gnu* | i[34567]8
 		;;
 	esac
 	;;
-x86_64-*-linux* | x86_64-*-kfreebsd*-gnu)
+x86_64-*-linux* | x86_64-*-kfreebsd*-gnu | x86_64-*-gnu*)
 	tm_file="${tm_file} i386/unix.h i386/att.h elfos.h gnu-user.h glibc-stdint.h \
 		 i386/x86-64.h i386/gnu-user-common.h i386/gnu-user64.h"
 	case ${target} in
@@ -2018,6 +2023,9 @@ x86_64-*-linux* | x86_64-*-kfreebsd*-gnu)
 	x86_64-*-kfreebsd*-gnu)
 		tm_file="${tm_file} kfreebsd-gnu.h i386/kfreebsd-gnu64.h"
 		;;
+	x86_64-*-gnu*)
+		tm_file="${tm_file} gnu.h i386/gnu64.h"
+		;;
 	esac
 	tmake_file="${tmake_file} i386/t-linux64"
 	x86_multilibs="${with_multilib_list}"
@@ -2455,6 +2463,7 @@ riscv*-*-linux*)
 	*) echo "Unknown value for enable_multilib"; exit 1
 	esac
 	tmake_file="${tmake_file} riscv/t-riscv riscv/t-linux"
+	tm_defines="${tm_defines} TARGET_DEFAULT_ASYNC_UNWIND_TABLES=1"
 	gnu_ld=yes
 	gas=yes
 	case $target in
@@ -4435,6 +4444,7 @@ case "${target}" in
 				# through to the multilib selector
 				with_float="soft"
 				tmake_file="${tmake_file} ${tmake_profile_file}"
+				tm_file="$tm_file arm/arm-mlib.h"
 				TM_MULTILIB_CONFIG="$with_multilib_list"
 			fi
 		fi
diff --git a/gcc/config/aarch64/aarch64-c.cc b/gcc/config/aarch64/aarch64-c.cc
index 4df6cc6..578ec6f 100644
--- a/gcc/config/aarch64/aarch64-c.cc
+++ b/gcc/config/aarch64/aarch64-c.cc
@@ -179,18 +179,18 @@ aarch64_update_cpp_builtins (cpp_reader *pfile)
   aarch64_def_or_undef (TARGET_RNG, "__ARM_FEATURE_RNG", pfile);
   aarch64_def_or_undef (TARGET_MEMTAG, "__ARM_FEATURE_MEMORY_TAGGING", pfile);
 
-  aarch64_def_or_undef (aarch64_bti_enabled (),
+  aarch64_def_or_undef (aarch_bti_enabled (),
 			"__ARM_FEATURE_BTI_DEFAULT", pfile);
 
   cpp_undef (pfile, "__ARM_FEATURE_PAC_DEFAULT");
-  if (aarch64_ra_sign_scope != AARCH64_FUNCTION_NONE)
+  if (aarch_ra_sign_scope != AARCH_FUNCTION_NONE)
     {
       int v = 0;
-      if (aarch64_ra_sign_key == AARCH64_KEY_A)
+      if (aarch_ra_sign_key == AARCH_KEY_A)
 	v |= 1;
-      if (aarch64_ra_sign_key == AARCH64_KEY_B)
+      if (aarch_ra_sign_key == AARCH_KEY_B)
 	v |= 2;
-      if (aarch64_ra_sign_scope == AARCH64_FUNCTION_ALL)
+      if (aarch_ra_sign_scope == AARCH_FUNCTION_ALL)
 	v |= 4;
       builtin_define_with_int_value ("__ARM_FEATURE_PAC_DEFAULT", v);
     }
diff --git a/gcc/config/aarch64/aarch64-cores.def b/gcc/config/aarch64/aarch64-cores.def
index 2a0f52e..85fdfd8 100644
--- a/gcc/config/aarch64/aarch64-cores.def
+++ b/gcc/config/aarch64/aarch64-cores.def
@@ -70,7 +70,7 @@ AARCH64_CORE("thunderxt83",   thunderxt83,   thunderx,  V8A,  (CRC, CRYPTO), thu
 
 /* Ampere Computing ('\xC0') cores. */
 AARCH64_CORE("ampere1", ampere1, cortexa57, V8_6A, (F16, RNG, AES, SHA3), ampere1, 0xC0, 0xac3, -1)
-AARCH64_CORE("ampere1a", ampere1a, cortexa57, V8_6A, (F16, RNG, AES, SHA3, MEMTAG), ampere1a, 0xC0, 0xac4, -1)
+AARCH64_CORE("ampere1a", ampere1a, cortexa57, V8_6A, (F16, RNG, AES, SHA3, SM4, MEMTAG), ampere1a, 0xC0, 0xac4, -1)
 /* Do not swap around "emag" and "xgene1",
    this order is required to handle variant correctly. */
 AARCH64_CORE("emag",        emag,      xgene1,    V8A,  (CRC, CRYPTO), emag, 0x50, 0x000, 3)
diff --git a/gcc/config/aarch64/aarch64-option-extensions.def b/gcc/config/aarch64/aarch64-option-extensions.def
index 36c1fbb..825f3bf 100644
--- a/gcc/config/aarch64/aarch64-option-extensions.def
+++ b/gcc/config/aarch64/aarch64-option-extensions.def
@@ -149,6 +149,6 @@ AARCH64_OPT_EXTENSION("ls64", LS64, (), (), (), "")
 
 AARCH64_OPT_EXTENSION("mops", MOPS, (), (), (), "")
 
-AARCH64_OPT_EXTENSION("cssc", CSSC, (), (), (), "")
+AARCH64_OPT_EXTENSION("cssc", CSSC, (), (), (), "cssc")
 
 #undef AARCH64_OPT_EXTENSION
diff --git a/gcc/config/aarch64/aarch64-opts.h b/gcc/config/aarch64/aarch64-opts.h
index c4431e7..a9f3e27 100644
--- a/gcc/config/aarch64/aarch64-opts.h
+++ b/gcc/config/aarch64/aarch64-opts.h
@@ -75,16 +75,6 @@ enum aarch64_code_model {
   AARCH64_CMODEL_LARGE
 };
 
-/* Function types -msign-return-address should sign.  */
-enum aarch64_function_type {
-  /* Don't sign any function.  */
-  AARCH64_FUNCTION_NONE,
-  /* Non-leaf functions.  */
-  AARCH64_FUNCTION_NON_LEAF,
-  /* All functions.  */
-  AARCH64_FUNCTION_ALL
-};
-
 /* SVE vector register sizes.  */
 enum aarch64_sve_vector_bits_enum {
   SVE_SCALABLE,
diff --git a/gcc/config/aarch64/aarch64-protos.h b/gcc/config/aarch64/aarch64-protos.h
index b57e7a9..6ab6d49 100644
--- a/gcc/config/aarch64/aarch64-protos.h
+++ b/gcc/config/aarch64/aarch64-protos.h
@@ -23,6 +23,7 @@
 #define GCC_AARCH64_PROTOS_H
 
 #include "input.h"
+#include "config/arm/aarch-common.h"
 
 /* SYMBOL_SMALL_ABSOLUTE: Generate symbol accesses through
    high and lo relocs that calculate the base address using a PC
@@ -651,18 +652,6 @@ enum aarch64_extra_tuning_flags
   AARCH64_EXTRA_TUNE_ALL = (1u << AARCH64_EXTRA_TUNE_index_END) - 1
 };
 
-/* Enum describing the various ways that the
-   aarch64_parse_{arch,tune,cpu,extension} functions can fail.
-   This way their callers can choose what kind of error to give.  */
-
-enum aarch64_parse_opt_result
-{
-  AARCH64_PARSE_OK,			/* Parsing was successful.  */
-  AARCH64_PARSE_MISSING_ARG,		/* Missing argument.  */
-  AARCH64_PARSE_INVALID_FEATURE,	/* Invalid feature modifier.  */
-  AARCH64_PARSE_INVALID_ARG		/* Invalid arch, tune, cpu arg.  */
-};
-
 /* Enum to distinguish which type of check is to be done in
    aarch64_simd_valid_immediate.  This is used as a bitmask where
    AARCH64_CHECK_MOV has both bits set.  Thus AARCH64_CHECK_MOV will
@@ -673,6 +662,8 @@ enum simd_immediate_check {
   AARCH64_CHECK_MOV  = AARCH64_CHECK_ORR | AARCH64_CHECK_BIC
 };
 
+extern enum aarch_key_type aarch_ra_sign_key;
+
 extern struct tune_params aarch64_tune_params;
 
 /* The available SVE predicate patterns, known in the ACLE as "svpattern".  */
@@ -914,7 +905,6 @@ void aarch64_register_pragmas (void);
 void aarch64_relayout_simd_types (void);
 void aarch64_reset_previous_fndecl (void);
 bool aarch64_return_address_signing_enabled (void);
-bool aarch64_bti_enabled (void);
 void aarch64_save_restore_target_globals (tree);
 void aarch64_addti_scratch_regs (rtx, rtx, rtx *,
 				 rtx *, rtx *,
@@ -1038,9 +1028,9 @@ void aarch64_set_asm_isa_flags (gcc_options *, aarch64_feature_flags);
 bool aarch64_handle_option (struct gcc_options *, struct gcc_options *,
 			     const struct cl_decoded_option *, location_t);
 const char *aarch64_rewrite_selected_cpu (const char *name);
-enum aarch64_parse_opt_result aarch64_parse_extension (const char *,
-						       aarch64_feature_flags *,
-						       std::string *);
+enum aarch_parse_opt_result aarch64_parse_extension (const char *,
+                                                     aarch64_feature_flags *,
+                                                     std::string *);
 void aarch64_get_all_extension_candidates (auto_vec<const char *> *candidates);
 std::string aarch64_get_extension_string_for_isa_flags (aarch64_feature_flags,
 							aarch64_feature_flags);
diff --git a/gcc/config/aarch64/aarch64-simd.md b/gcc/config/aarch64/aarch64-simd.md
index 31d9e89..7f212bf 100644
--- a/gcc/config/aarch64/aarch64-simd.md
+++ b/gcc/config/aarch64/aarch64-simd.md
@@ -1064,7 +1064,7 @@
 		(match_operand:<VEL> 1 "aarch64_simd_nonimmediate_operand" "w,?r,Utv"))
 	    (match_operand:VALL_F16 3 "register_operand" "0,0,0")
 	    (match_operand:SI 2 "immediate_operand" "i,i,i")))]
-  "TARGET_SIMD"
+  "TARGET_SIMD && exact_log2 (INTVAL (operands[2])) >= 0"
   {
    int elt = ENDIAN_LANE_N (<nunits>, exact_log2 (INTVAL (operands[2])));
    operands[2] = GEN_INT ((HOST_WIDE_INT) 1 << elt);
@@ -1093,7 +1093,7 @@
 		  [(match_operand:SI 4 "immediate_operand" "i")])))
 	    (match_operand:VALL_F16 1 "register_operand" "0")
 	    (match_operand:SI 2 "immediate_operand" "i")))]
-  "TARGET_SIMD"
+  "TARGET_SIMD && exact_log2 (INTVAL (operands[2])) >= 0"
   {
     int elt = ENDIAN_LANE_N (<nunits>, exact_log2 (INTVAL (operands[2])));
     operands[2] = GEN_INT (HOST_WIDE_INT_1 << elt);
@@ -1114,7 +1114,7 @@
 		  [(match_operand:SI 4 "immediate_operand" "i")])))
 	    (match_operand:VALL_F16_NO_V2Q 1 "register_operand" "0")
 	    (match_operand:SI 2 "immediate_operand" "i")))]
-  "TARGET_SIMD"
+  "TARGET_SIMD && exact_log2 (INTVAL (operands[2])) >= 0"
   {
     int elt = ENDIAN_LANE_N (<nunits>, exact_log2 (INTVAL (operands[2])));
     operands[2] = GEN_INT (HOST_WIDE_INT_1 << elt);
diff --git a/gcc/config/aarch64/aarch64.cc b/gcc/config/aarch64/aarch64.cc
index d36b573..17c1e23 100644
--- a/gcc/config/aarch64/aarch64.cc
+++ b/gcc/config/aarch64/aarch64.cc
@@ -82,6 +82,8 @@
 #include "tree-dfa.h"
 #include "asan.h"
 #include "aarch64-feature-deps.h"
+#include "config/arm/aarch-common.h"
+#include "config/arm/aarch-common-protos.h"
 
 /* This file should be included last.  */
 #include "target-def.h"
@@ -318,12 +320,8 @@ bool aarch64_pcrelative_literal_loads;
 /* Global flag for whether frame pointer is enabled.  */
 bool aarch64_use_frame_pointer;
 
-#define BRANCH_PROTECT_STR_MAX 255
 char *accepted_branch_protection_string = NULL;
 
-static enum aarch64_parse_opt_result
-aarch64_parse_branch_protection (const char*, char**);
-
 /* Support for command line parsing of boolean flags in the tuning
    structures.  */
 struct aarch64_flag_desc
@@ -2761,6 +2759,8 @@ static const struct processor all_cores[] =
   {NULL, aarch64_none, aarch64_none, aarch64_no_arch, 0, NULL}
 };
 
+enum aarch_key_type aarch_ra_sign_key = AARCH_KEY_A;
+
 /* The current tuning set.  */
 struct tune_params aarch64_tune_params = generic_tunings;
 
@@ -2826,100 +2826,6 @@ aarch64_cc;
 
 #define AARCH64_INVERSE_CONDITION_CODE(X) ((aarch64_cc) (((int) X) ^ 1))
 
-struct aarch64_branch_protect_type
-{
-  /* The type's name that the user passes to the branch-protection option
-    string.  */
-  const char* name;
-  /* Function to handle the protection type and set global variables.
-    First argument is the string token corresponding with this type and the
-    second argument is the next token in the option string.
-    Return values:
-    * AARCH64_PARSE_OK: Handling was sucessful.
-    * AARCH64_INVALID_ARG: The type is invalid in this context and the caller
-      should print an error.
-    * AARCH64_INVALID_FEATURE: The type is invalid and the handler prints its
-      own error.  */
-  enum aarch64_parse_opt_result (*handler)(char*, char*);
-  /* A list of types that can follow this type in the option string.  */
-  const aarch64_branch_protect_type* subtypes;
-  unsigned int num_subtypes;
-};
-
-static enum aarch64_parse_opt_result
-aarch64_handle_no_branch_protection (char* str, char* rest)
-{
-  aarch64_ra_sign_scope = AARCH64_FUNCTION_NONE;
-  aarch64_enable_bti = 0;
-  if (rest)
-    {
-      error ("unexpected %<%s%> after %<%s%>", rest, str);
-      return AARCH64_PARSE_INVALID_FEATURE;
-    }
-  return AARCH64_PARSE_OK;
-}
-
-static enum aarch64_parse_opt_result
-aarch64_handle_standard_branch_protection (char* str, char* rest)
-{
-  aarch64_ra_sign_scope = AARCH64_FUNCTION_NON_LEAF;
-  aarch64_ra_sign_key = AARCH64_KEY_A;
-  aarch64_enable_bti = 1;
-  if (rest)
-    {
-      error ("unexpected %<%s%> after %<%s%>", rest, str);
-      return AARCH64_PARSE_INVALID_FEATURE;
-    }
-  return AARCH64_PARSE_OK;
-}
-
-static enum aarch64_parse_opt_result
-aarch64_handle_pac_ret_protection (char* str ATTRIBUTE_UNUSED,
-				    char* rest ATTRIBUTE_UNUSED)
-{
-  aarch64_ra_sign_scope = AARCH64_FUNCTION_NON_LEAF;
-  aarch64_ra_sign_key = AARCH64_KEY_A;
-  return AARCH64_PARSE_OK;
-}
-
-static enum aarch64_parse_opt_result
-aarch64_handle_pac_ret_leaf (char* str ATTRIBUTE_UNUSED,
-			      char* rest ATTRIBUTE_UNUSED)
-{
-  aarch64_ra_sign_scope = AARCH64_FUNCTION_ALL;
-  return AARCH64_PARSE_OK;
-}
-
-static enum aarch64_parse_opt_result
-aarch64_handle_pac_ret_b_key (char* str ATTRIBUTE_UNUSED,
-			      char* rest ATTRIBUTE_UNUSED)
-{
-  aarch64_ra_sign_key = AARCH64_KEY_B;
-  return AARCH64_PARSE_OK;
-}
-
-static enum aarch64_parse_opt_result
-aarch64_handle_bti_protection (char* str ATTRIBUTE_UNUSED,
-				    char* rest ATTRIBUTE_UNUSED)
-{
-  aarch64_enable_bti = 1;
-  return AARCH64_PARSE_OK;
-}
-
-static const struct aarch64_branch_protect_type aarch64_pac_ret_subtypes[] = {
-  { "leaf", aarch64_handle_pac_ret_leaf, NULL, 0 },
-  { "b-key", aarch64_handle_pac_ret_b_key, NULL, 0 },
-  { NULL, NULL, NULL, 0 }
-};
-
-static const struct aarch64_branch_protect_type aarch64_branch_protect_types[] = {
-  { "none", aarch64_handle_no_branch_protection, NULL, 0 },
-  { "standard", aarch64_handle_standard_branch_protection, NULL, 0 },
-  { "pac-ret", aarch64_handle_pac_ret_protection, aarch64_pac_ret_subtypes,
-    ARRAY_SIZE (aarch64_pac_ret_subtypes) },
-  { "bti", aarch64_handle_bti_protection, NULL, 0 },
-  { NULL, NULL, NULL, 0 }
-};
 
 /* The condition codes of the processor, and the inverse function.  */
 static const char * const aarch64_condition_codes[] =
@@ -7659,7 +7565,18 @@ aarch64_layout_arg (cumulative_args_t pcum_v, const function_arg_info &arg)
        && (currently_expanding_function_start
 	   || currently_expanding_gimple_stmt));
 
-  /* There are several things to note here:
+  /* HFAs and HVAs can have an alignment greater than 16 bytes.  For example:
+
+       typedef struct foo {
+         __Int8x16_t foo[2] __attribute__((aligned(32)));
+       } foo;
+
+     is still a HVA despite its larger-than-normal alignment.
+     However, such over-aligned HFAs and HVAs are guaranteed to have
+     no padding.
+
+     If we exclude HFAs and HVAs from the discussion below, then there
+     are several things to note:
 
      - Both the C and AAPCS64 interpretations of a type's alignment should
        give a value that is no greater than the type's size.
@@ -7704,12 +7621,6 @@ aarch64_layout_arg (cumulative_args_t pcum_v, const function_arg_info &arg)
        would treat the alignment as though it was *equal to* 16 bytes.
 
      Both behaviors were wrong, but in different cases.  */
-  unsigned int alignment
-    = aarch64_function_arg_alignment (mode, type, &abi_break,
-				      &abi_break_packed);
-  gcc_assert (alignment <= 16 * BITS_PER_UNIT
-	      && (!alignment || abi_break < alignment)
-	      && (!abi_break_packed || alignment < abi_break_packed));
 
   pcum->aapcs_arg_processed = true;
 
@@ -7780,6 +7691,14 @@ aarch64_layout_arg (cumulative_args_t pcum_v, const function_arg_info &arg)
 						 &nregs);
   gcc_assert (!sve_p || !allocate_nvrn);
 
+  unsigned int alignment
+    = aarch64_function_arg_alignment (mode, type, &abi_break,
+				      &abi_break_packed);
+
+  gcc_assert ((allocate_nvrn || alignment <= 16 * BITS_PER_UNIT)
+	      && (!alignment || abi_break < alignment)
+	      && (!abi_break_packed || alignment < abi_break_packed));
+
   /* allocate_ncrn may be false-positive, but allocate_nvrn is quite reliable.
      The following code thus handles passing by SIMD/FP registers first.  */
 
@@ -9007,18 +8926,72 @@ aarch64_return_address_signing_enabled (void)
   if (crtl->calls_eh_return)
     return false;
 
-  /* If signing scope is AARCH64_FUNCTION_NON_LEAF, we only sign a leaf function
+  /* If signing scope is AARCH_FUNCTION_NON_LEAF, we only sign a leaf function
      if its LR is pushed onto stack.  */
-  return (aarch64_ra_sign_scope == AARCH64_FUNCTION_ALL
-	  || (aarch64_ra_sign_scope == AARCH64_FUNCTION_NON_LEAF
+  return (aarch_ra_sign_scope == AARCH_FUNCTION_ALL
+	  || (aarch_ra_sign_scope == AARCH_FUNCTION_NON_LEAF
 	      && known_ge (cfun->machine->frame.reg_offset[LR_REGNUM], 0)));
 }
 
+/* Only used by the arm backend.  */
+void aarch_bti_arch_check (void)
+{}
+
 /* Return TRUE if Branch Target Identification Mechanism is enabled.  */
 bool
-aarch64_bti_enabled (void)
+aarch_bti_enabled (void)
+{
+  return (aarch_enable_bti == 1);
+}
+
+/* Check if INSN is a BTI J insn.  */
+bool
+aarch_bti_j_insn_p (rtx_insn *insn)
+{
+  if (!insn || !INSN_P (insn))
+    return false;
+
+  rtx pat = PATTERN (insn);
+  return GET_CODE (pat) == UNSPEC_VOLATILE && XINT (pat, 1) == UNSPECV_BTI_J;
+}
+
+/* Check if X (or any sub-rtx of X) is a PACIASP/PACIBSP instruction.  */
+bool
+aarch_pac_insn_p (rtx x)
+{
+  if (!INSN_P (x))
+    return false;
+
+  subrtx_var_iterator::array_type array;
+  FOR_EACH_SUBRTX_VAR (iter, array, PATTERN (x), ALL)
+    {
+      rtx sub = *iter;
+      if (sub && GET_CODE (sub) == UNSPEC)
+	{
+	  int unspec_val = XINT (sub, 1);
+	  switch (unspec_val)
+	    {
+	    case UNSPEC_PACIASP:
+            case UNSPEC_PACIBSP:
+	      return true;
+
+	    default:
+	      return false;
+	    }
+	  iter.skip_subrtxes ();
+	}
+    }
+  return false;
+}
+
+rtx aarch_gen_bti_c (void)
+{
+  return gen_bti_c ();
+}
+
+rtx aarch_gen_bti_j (void)
 {
-  return (aarch64_enable_bti == 1);
+  return gen_bti_j ();
 }
 
 /* The caller is going to use ST1D or LD1D to save or restore an SVE
@@ -10010,12 +9983,12 @@ aarch64_expand_prologue (void)
   /* Sign return address for functions.  */
   if (aarch64_return_address_signing_enabled ())
     {
-      switch (aarch64_ra_sign_key)
+      switch (aarch_ra_sign_key)
 	{
-	  case AARCH64_KEY_A:
+	  case AARCH_KEY_A:
 	    insn = emit_insn (gen_paciasp ());
 	    break;
-	  case AARCH64_KEY_B:
+	  case AARCH_KEY_B:
 	    insn = emit_insn (gen_pacibsp ());
 	    break;
 	  default:
@@ -10316,12 +10289,12 @@ aarch64_expand_epilogue (bool for_sibcall)
   if (aarch64_return_address_signing_enabled ()
       && (for_sibcall || !TARGET_ARMV8_3))
     {
-      switch (aarch64_ra_sign_key)
+      switch (aarch_ra_sign_key)
 	{
-	  case AARCH64_KEY_A:
+	  case AARCH_KEY_A:
 	    insn = emit_insn (gen_autiasp ());
 	    break;
-	  case AARCH64_KEY_B:
+	  case AARCH_KEY_B:
 	    insn = emit_insn (gen_autibsp ());
 	    break;
 	  default:
@@ -10400,7 +10373,7 @@ aarch64_output_mi_thunk (FILE *file, tree thunk ATTRIBUTE_UNUSED,
   rtx_insn *insn;
   const char *fnname = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (thunk));
 
-  if (aarch64_bti_enabled ())
+  if (aarch_bti_enabled ())
     emit_insn (gen_bti_c());
 
   reload_completed = 1;
@@ -13049,7 +13022,7 @@ aarch64_output_casesi (rtx *operands)
 int
 aarch64_uxt_size (int shift, HOST_WIDE_INT mask)
 {
-  if (shift >= 0 && shift <= 3)
+  if (shift >= 0 && shift <= 4)
     {
       int size;
       for (size = 8; size <= 32; size *= 2)
@@ -17346,12 +17319,12 @@ static void initialize_aarch64_code_model (struct gcc_options *);
 
 /* Parse the TO_PARSE string and put the architecture struct that it
    selects into RES and the architectural features into ISA_FLAGS.
-   Return an aarch64_parse_opt_result describing the parse result.
+   Return an aarch_parse_opt_result describing the parse result.
    If there is an error parsing, RES and ISA_FLAGS are left unchanged.
    When the TO_PARSE string contains an invalid extension,
    a copy of the string is created and stored to INVALID_EXTENSION.  */
 
-static enum aarch64_parse_opt_result
+static enum aarch_parse_opt_result
 aarch64_parse_arch (const char *to_parse, const struct processor **res,
 		    aarch64_feature_flags *isa_flags,
 		    std::string *invalid_extension)
@@ -17368,7 +17341,7 @@ aarch64_parse_arch (const char *to_parse, const struct processor **res,
     len = strlen (to_parse);
 
   if (len == 0)
-    return AARCH64_PARSE_MISSING_ARG;
+    return AARCH_PARSE_MISSING_ARG;
 
 
   /* Loop through the list of supported ARCHes to find a match.  */
@@ -17382,32 +17355,32 @@ aarch64_parse_arch (const char *to_parse, const struct processor **res,
 	  if (ext != NULL)
 	    {
 	      /* TO_PARSE string contains at least one extension.  */
-	      enum aarch64_parse_opt_result ext_res
+	      enum aarch_parse_opt_result ext_res
 		= aarch64_parse_extension (ext, &isa_temp, invalid_extension);
 
-	      if (ext_res != AARCH64_PARSE_OK)
+	      if (ext_res != AARCH_PARSE_OK)
 		return ext_res;
 	    }
 	  /* Extension parsing was successful.  Confirm the result
 	     arch and ISA flags.  */
 	  *res = arch;
 	  *isa_flags = isa_temp;
-	  return AARCH64_PARSE_OK;
+	  return AARCH_PARSE_OK;
 	}
     }
 
   /* ARCH name not found in list.  */
-  return AARCH64_PARSE_INVALID_ARG;
+  return AARCH_PARSE_INVALID_ARG;
 }
 
 /* Parse the TO_PARSE string and put the result tuning in RES and the
-   architecture flags in ISA_FLAGS.  Return an aarch64_parse_opt_result
+   architecture flags in ISA_FLAGS.  Return an aarch_parse_opt_result
    describing the parse result.  If there is an error parsing, RES and
    ISA_FLAGS are left unchanged.
    When the TO_PARSE string contains an invalid extension,
    a copy of the string is created and stored to INVALID_EXTENSION.  */
 
-static enum aarch64_parse_opt_result
+static enum aarch_parse_opt_result
 aarch64_parse_cpu (const char *to_parse, const struct processor **res,
 		   aarch64_feature_flags *isa_flags,
 		   std::string *invalid_extension)
@@ -17424,7 +17397,7 @@ aarch64_parse_cpu (const char *to_parse, const struct processor **res,
     len = strlen (to_parse);
 
   if (len == 0)
-    return AARCH64_PARSE_MISSING_ARG;
+    return AARCH_PARSE_MISSING_ARG;
 
 
   /* Loop through the list of supported CPUs to find a match.  */
@@ -17437,29 +17410,29 @@ aarch64_parse_cpu (const char *to_parse, const struct processor **res,
 	  if (ext != NULL)
 	    {
 	      /* TO_PARSE string contains at least one extension.  */
-	      enum aarch64_parse_opt_result ext_res
+	      enum aarch_parse_opt_result ext_res
 		= aarch64_parse_extension (ext, &isa_temp, invalid_extension);
 
-	      if (ext_res != AARCH64_PARSE_OK)
+	      if (ext_res != AARCH_PARSE_OK)
 		return ext_res;
 	    }
 	  /* Extension parsing was successfull.  Confirm the result
 	     cpu and ISA flags.  */
 	  *res = cpu;
 	  *isa_flags = isa_temp;
-	  return AARCH64_PARSE_OK;
+	  return AARCH_PARSE_OK;
 	}
     }
 
   /* CPU name not found in list.  */
-  return AARCH64_PARSE_INVALID_ARG;
+  return AARCH_PARSE_INVALID_ARG;
 }
 
 /* Parse the TO_PARSE string and put the cpu it selects into RES.
-   Return an aarch64_parse_opt_result describing the parse result.
+   Return an aarch_parse_opt_result describing the parse result.
    If the parsing fails the RES does not change.  */
 
-static enum aarch64_parse_opt_result
+static enum aarch_parse_opt_result
 aarch64_parse_tune (const char *to_parse, const struct processor **res)
 {
   const struct processor *cpu;
@@ -17470,12 +17443,12 @@ aarch64_parse_tune (const char *to_parse, const struct processor **res)
       if (strcmp (cpu->name, to_parse) == 0)
 	{
 	  *res = cpu;
-	  return AARCH64_PARSE_OK;
+	  return AARCH_PARSE_OK;
 	}
     }
 
   /* CPU name not found in list.  */
-  return AARCH64_PARSE_INVALID_ARG;
+  return AARCH_PARSE_INVALID_ARG;
 }
 
 /* Parse TOKEN, which has length LENGTH to see if it is an option
@@ -18066,22 +18039,22 @@ aarch64_validate_mcpu (const char *str, const struct processor **res,
 		       aarch64_feature_flags *isa_flags)
 {
   std::string invalid_extension;
-  enum aarch64_parse_opt_result parse_res
+  enum aarch_parse_opt_result parse_res
     = aarch64_parse_cpu (str, res, isa_flags, &invalid_extension);
 
-  if (parse_res == AARCH64_PARSE_OK)
+  if (parse_res == AARCH_PARSE_OK)
     return true;
 
   switch (parse_res)
     {
-      case AARCH64_PARSE_MISSING_ARG:
+      case AARCH_PARSE_MISSING_ARG:
 	error ("missing cpu name in %<-mcpu=%s%>", str);
 	break;
-      case AARCH64_PARSE_INVALID_ARG:
+      case AARCH_PARSE_INVALID_ARG:
 	error ("unknown value %qs for %<-mcpu%>", str);
 	aarch64_print_hint_for_core (str);
 	break;
-      case AARCH64_PARSE_INVALID_FEATURE:
+      case AARCH_PARSE_INVALID_FEATURE:
 	error ("invalid feature modifier %qs in %<-mcpu=%s%>",
 	       invalid_extension.c_str (), str);
 	aarch64_print_hint_for_extensions (invalid_extension);
@@ -18166,110 +18139,6 @@ aarch64_validate_sls_mitigation (const char *const_str)
   free (str_root);
 }
 
-/* Parses CONST_STR for branch protection features specified in
-   aarch64_branch_protect_types, and set any global variables required.  Returns
-   the parsing result and assigns LAST_STR to the last processed token from
-   CONST_STR so that it can be used for error reporting.  */
-
-static enum
-aarch64_parse_opt_result aarch64_parse_branch_protection (const char *const_str,
-							  char** last_str)
-{
-  char *str_root = xstrdup (const_str);
-  char* token_save = NULL;
-  char *str = strtok_r (str_root, "+", &token_save);
-  enum aarch64_parse_opt_result res = AARCH64_PARSE_OK;
-  if (!str)
-    res = AARCH64_PARSE_MISSING_ARG;
-  else
-    {
-      char *next_str = strtok_r (NULL, "+", &token_save);
-      /* Reset the branch protection features to their defaults.  */
-      aarch64_handle_no_branch_protection (NULL, NULL);
-
-      while (str && res == AARCH64_PARSE_OK)
-	{
-	  const aarch64_branch_protect_type* type = aarch64_branch_protect_types;
-	  bool found = false;
-	  /* Search for this type.  */
-	  while (type && type->name && !found && res == AARCH64_PARSE_OK)
-	    {
-	      if (strcmp (str, type->name) == 0)
-		{
-		  found = true;
-		  res = type->handler (str, next_str);
-		  str = next_str;
-		  next_str = strtok_r (NULL, "+", &token_save);
-		}
-	      else
-		type++;
-	    }
-	  if (found && res == AARCH64_PARSE_OK)
-	    {
-	      bool found_subtype = true;
-	      /* Loop through each token until we find one that isn't a
-		 subtype.  */
-	      while (found_subtype)
-		{
-		  found_subtype = false;
-		  const aarch64_branch_protect_type *subtype = type->subtypes;
-		  /* Search for the subtype.  */
-		  while (str && subtype && subtype->name && !found_subtype
-			  && res == AARCH64_PARSE_OK)
-		    {
-		      if (strcmp (str, subtype->name) == 0)
-			{
-			  found_subtype = true;
-			  res = subtype->handler (str, next_str);
-			  str = next_str;
-			  next_str = strtok_r (NULL, "+", &token_save);
-			}
-		      else
-			subtype++;
-		    }
-		}
-	    }
-	  else if (!found)
-	    res = AARCH64_PARSE_INVALID_ARG;
-	}
-    }
-  /* Copy the last processed token into the argument to pass it back.
-    Used by option and attribute validation to print the offending token.  */
-  if (last_str)
-    {
-      if (str) strcpy (*last_str, str);
-      else *last_str = NULL;
-    }
-  if (res == AARCH64_PARSE_OK)
-    {
-      /* If needed, alloc the accepted string then copy in const_str.
-	Used by override_option_after_change_1.  */
-      if (!accepted_branch_protection_string)
-	accepted_branch_protection_string = (char *) xmalloc (
-						      BRANCH_PROTECT_STR_MAX
-							+ 1);
-      strncpy (accepted_branch_protection_string, const_str,
-		BRANCH_PROTECT_STR_MAX + 1);
-      /* Forcibly null-terminate.  */
-      accepted_branch_protection_string[BRANCH_PROTECT_STR_MAX] = '\0';
-    }
-  return res;
-}
-
-static bool
-aarch64_validate_mbranch_protection (const char *const_str)
-{
-  char *str = (char *) xmalloc (strlen (const_str));
-  enum aarch64_parse_opt_result res =
-    aarch64_parse_branch_protection (const_str, &str);
-  if (res == AARCH64_PARSE_INVALID_ARG)
-    error ("invalid argument %<%s%> for %<-mbranch-protection=%>", str);
-  else if (res == AARCH64_PARSE_MISSING_ARG)
-    error ("missing argument for %<-mbranch-protection=%>");
-  free (str);
-  return res == AARCH64_PARSE_OK;
-}
-
 /* Validate a command-line -march option.  Parse the arch and extensions
    (if any) specified in STR and throw errors if appropriate.  Put the
    results, if they are valid, in RES and ISA_FLAGS.  Return whether the
@@ -18280,27 +18149,27 @@ aarch64_validate_march (const char *str, const struct processor **res,
 			aarch64_feature_flags *isa_flags)
 {
   std::string invalid_extension;
-  enum aarch64_parse_opt_result parse_res
+  enum aarch_parse_opt_result parse_res
     = aarch64_parse_arch (str, res, isa_flags, &invalid_extension);
 
-  if (parse_res == AARCH64_PARSE_OK)
+  if (parse_res == AARCH_PARSE_OK)
     return true;
 
   switch (parse_res)
     {
-      case AARCH64_PARSE_MISSING_ARG:
+      case AARCH_PARSE_MISSING_ARG:
 	error ("missing arch name in %<-march=%s%>", str);
 	break;
-      case AARCH64_PARSE_INVALID_ARG:
+      case AARCH_PARSE_INVALID_ARG:
 	error ("unknown value %qs for %<-march%>", str);
 	aarch64_print_hint_for_arch (str);
 	/* A common user error is confusing -march and -mcpu.
 	   If the -march string matches a known CPU suggest -mcpu.  */
 	parse_res = aarch64_parse_cpu (str, res, isa_flags, &invalid_extension);
-	if (parse_res == AARCH64_PARSE_OK)
+	if (parse_res == AARCH_PARSE_OK)
 	  inform (input_location, "did you mean %<-mcpu=%s%>?", str);
 	break;
-      case AARCH64_PARSE_INVALID_FEATURE:
+      case AARCH_PARSE_INVALID_FEATURE:
 	error ("invalid feature modifier %qs in %<-march=%s%>",
 	       invalid_extension.c_str (), str);
 	aarch64_print_hint_for_extensions (invalid_extension);
@@ -18320,18 +18189,18 @@ aarch64_validate_march (const char *str, const struct processor **res,
 static bool
 aarch64_validate_mtune (const char *str, const struct processor **res)
 {
-  enum aarch64_parse_opt_result parse_res
+  enum aarch_parse_opt_result parse_res
     = aarch64_parse_tune (str, res);
 
-  if (parse_res == AARCH64_PARSE_OK)
+  if (parse_res == AARCH_PARSE_OK)
     return true;
 
   switch (parse_res)
     {
-      case AARCH64_PARSE_MISSING_ARG:
+      case AARCH_PARSE_MISSING_ARG:
 	error ("missing cpu name in %<-mtune=%s%>", str);
 	break;
-      case AARCH64_PARSE_INVALID_ARG:
+      case AARCH_PARSE_INVALID_ARG:
 	error ("unknown value %qs for %<-mtune%>", str);
 	aarch64_print_hint_for_core (str);
 	break;
@@ -18393,7 +18262,7 @@ aarch64_override_options (void)
     aarch64_validate_sls_mitigation (aarch64_harden_sls_string);
 
   if (aarch64_branch_protection_string)
-    aarch64_validate_mbranch_protection (aarch64_branch_protection_string);
+    aarch_validate_mbranch_protection (aarch64_branch_protection_string);
 
   /* -mcpu=CPU is shorthand for -march=ARCH_FOR_CPU, -mtune=CPU.
      If either of -march or -mtune is given, they override their
@@ -18446,12 +18315,12 @@ aarch64_override_options (void)
 
   selected_tune = tune ? tune->ident : cpu->ident;
 
-  if (aarch64_enable_bti == 2)
+  if (aarch_enable_bti == 2)
     {
 #ifdef TARGET_ENABLE_BTI
-      aarch64_enable_bti = 1;
+      aarch_enable_bti = 1;
 #else
-      aarch64_enable_bti = 0;
+      aarch_enable_bti = 0;
 #endif
     }
 
@@ -18461,9 +18330,9 @@ aarch64_override_options (void)
   if (!TARGET_ILP32 && accepted_branch_protection_string == NULL)
     {
 #ifdef TARGET_ENABLE_PAC_RET
-      aarch64_ra_sign_scope = AARCH64_FUNCTION_NON_LEAF;
+      aarch_ra_sign_scope = AARCH_FUNCTION_NON_LEAF;
 #else
-      aarch64_ra_sign_scope = AARCH64_FUNCTION_NONE;
+      aarch_ra_sign_scope = AARCH_FUNCTION_NONE;
 #endif
     }
 
@@ -18477,7 +18346,7 @@ aarch64_override_options (void)
   /* Convert -msve-vector-bits to a VG count.  */
   aarch64_sve_vg = aarch64_convert_sve_vector_bits (aarch64_sve_vector_bits);
 
-  if (aarch64_ra_sign_scope != AARCH64_FUNCTION_NONE && TARGET_ILP32)
+  if (aarch_ra_sign_scope != AARCH_FUNCTION_NONE && TARGET_ILP32)
     sorry ("return address signing is only supported for %<-mabi=lp64%>");
 
   /* The pass to insert speculation tracking runs before
@@ -18692,10 +18561,10 @@ aarch64_handle_attr_arch (const char *str)
   const struct processor *tmp_arch = NULL;
   std::string invalid_extension;
   aarch64_feature_flags tmp_flags;
-  enum aarch64_parse_opt_result parse_res
+  enum aarch_parse_opt_result parse_res
     = aarch64_parse_arch (str, &tmp_arch, &tmp_flags, &invalid_extension);
 
-  if (parse_res == AARCH64_PARSE_OK)
+  if (parse_res == AARCH_PARSE_OK)
     {
       gcc_assert (tmp_arch);
       selected_arch = tmp_arch->arch;
@@ -18705,14 +18574,14 @@ aarch64_handle_attr_arch (const char *str)
 
   switch (parse_res)
     {
-      case AARCH64_PARSE_MISSING_ARG:
+      case AARCH_PARSE_MISSING_ARG:
 	error ("missing name in %<target(\"arch=\")%> pragma or attribute");
 	break;
-      case AARCH64_PARSE_INVALID_ARG:
+      case AARCH_PARSE_INVALID_ARG:
 	error ("invalid name %qs in %<target(\"arch=\")%> pragma or attribute", str);
 	aarch64_print_hint_for_arch (str);
 	break;
-      case AARCH64_PARSE_INVALID_FEATURE:
+      case AARCH_PARSE_INVALID_FEATURE:
 	error ("invalid feature modifier %s of value %qs in "
 	       "%<target()%> pragma or attribute", invalid_extension.c_str (), str);
 	aarch64_print_hint_for_extensions (invalid_extension);
@@ -18732,10 +18601,10 @@ aarch64_handle_attr_cpu (const char *str)
   const struct processor *tmp_cpu = NULL;
   std::string invalid_extension;
   aarch64_feature_flags tmp_flags;
-  enum aarch64_parse_opt_result parse_res
+  enum aarch_parse_opt_result parse_res
     = aarch64_parse_cpu (str, &tmp_cpu, &tmp_flags, &invalid_extension);
 
-  if (parse_res == AARCH64_PARSE_OK)
+  if (parse_res == AARCH_PARSE_OK)
     {
       gcc_assert (tmp_cpu);
       selected_tune = tmp_cpu->ident;
@@ -18746,14 +18615,14 @@ aarch64_handle_attr_cpu (const char *str)
 
   switch (parse_res)
     {
-      case AARCH64_PARSE_MISSING_ARG:
+      case AARCH_PARSE_MISSING_ARG:
 	error ("missing name in %<target(\"cpu=\")%> pragma or attribute");
 	break;
-      case AARCH64_PARSE_INVALID_ARG:
+      case AARCH_PARSE_INVALID_ARG:
 	error ("invalid name %qs in %<target(\"cpu=\")%> pragma or attribute", str);
 	aarch64_print_hint_for_core (str);
 	break;
-      case AARCH64_PARSE_INVALID_FEATURE:
+      case AARCH_PARSE_INVALID_FEATURE:
 	error ("invalid feature modifier %qs of value %qs in "
 	       "%<target()%> pragma or attribute", invalid_extension.c_str (), str);
 	aarch64_print_hint_for_extensions (invalid_extension);
@@ -18771,23 +18640,23 @@ aarch64_handle_attr_cpu (const char *str)
  aarch64_handle_attr_branch_protection (const char* str)
  {
   char *err_str = (char *) xmalloc (strlen (str) + 1);
-  enum aarch64_parse_opt_result res = aarch64_parse_branch_protection (str,
-								      &err_str);
+  enum aarch_parse_opt_result res = aarch_parse_branch_protection (str,
+								   &err_str);
   bool success = false;
   switch (res)
     {
-     case AARCH64_PARSE_MISSING_ARG:
+     case AARCH_PARSE_MISSING_ARG:
        error ("missing argument to %<target(\"branch-protection=\")%> pragma or"
 	      " attribute");
        break;
-     case AARCH64_PARSE_INVALID_ARG:
+     case AARCH_PARSE_INVALID_ARG:
        error ("invalid protection type %qs in %<target(\"branch-protection"
 	      "=\")%> pragma or attribute", err_str);
        break;
-     case AARCH64_PARSE_OK:
+     case AARCH_PARSE_OK:
        success = true;
       /* Fall through.  */
-     case AARCH64_PARSE_INVALID_FEATURE:
+     case AARCH_PARSE_INVALID_FEATURE:
        break;
      default:
        gcc_unreachable ();
@@ -18802,10 +18671,10 @@ static bool
 aarch64_handle_attr_tune (const char *str)
 {
   const struct processor *tmp_tune = NULL;
-  enum aarch64_parse_opt_result parse_res
+  enum aarch_parse_opt_result parse_res
     = aarch64_parse_tune (str, &tmp_tune);
 
-  if (parse_res == AARCH64_PARSE_OK)
+  if (parse_res == AARCH_PARSE_OK)
     {
       gcc_assert (tmp_tune);
       selected_tune = tmp_tune->ident;
@@ -18814,7 +18683,7 @@ aarch64_handle_attr_tune (const char *str)
 
   switch (parse_res)
     {
-      case AARCH64_PARSE_INVALID_ARG:
+      case AARCH_PARSE_INVALID_ARG:
 	error ("invalid name %qs in %<target(\"tune=\")%> pragma or attribute", str);
 	aarch64_print_hint_for_core (str);
 	break;
@@ -18833,7 +18702,7 @@ aarch64_handle_attr_tune (const char *str)
 static bool
 aarch64_handle_attr_isa_flags (char *str)
 {
-  enum aarch64_parse_opt_result parse_res;
+  enum aarch_parse_opt_result parse_res;
   auto isa_flags = aarch64_asm_isa_flags;
 
   /* We allow "+nothing" in the beginning to clear out all architectural
@@ -18847,7 +18716,7 @@ aarch64_handle_attr_isa_flags (char *str)
   std::string invalid_extension;
   parse_res = aarch64_parse_extension (str, &isa_flags, &invalid_extension);
 
-  if (parse_res == AARCH64_PARSE_OK)
+  if (parse_res == AARCH_PARSE_OK)
     {
       aarch64_set_asm_isa_flags (isa_flags);
       return true;
@@ -18855,11 +18724,11 @@ aarch64_handle_attr_isa_flags (char *str)
 
   switch (parse_res)
     {
-      case AARCH64_PARSE_MISSING_ARG:
+      case AARCH_PARSE_MISSING_ARG:
 	error ("missing value in %<target()%> pragma or attribute");
 	break;
 
-      case AARCH64_PARSE_INVALID_FEATURE:
+      case AARCH_PARSE_INVALID_FEATURE:
 	error ("invalid feature modifier %qs of value %qs in "
 	       "%<target()%> pragma or attribute", invalid_extension.c_str (), str);
 	break;
@@ -19108,10 +18977,10 @@ aarch64_process_target_attr (tree args)
 	     leading '+'.  */
 	  aarch64_feature_flags isa_temp = 0;
 	  auto with_plus = std::string ("+") + token;
-	  enum aarch64_parse_opt_result ext_res
+	  enum aarch_parse_opt_result ext_res
 	    = aarch64_parse_extension (with_plus.c_str (), &isa_temp, nullptr);
 
-	  if (ext_res == AARCH64_PARSE_OK)
+	  if (ext_res == AARCH_PARSE_OK)
 	    error ("arch extension %<%s%> should be prefixed by %<+%>",
 		   token);
 	  else
@@ -22821,7 +22690,7 @@ aarch64_print_patchable_function_entry (FILE *file,
 			       GEN_INT (record_p));
   basic_block bb = ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb;
 
-  if (!aarch64_bti_enabled ()
+  if (!aarch_bti_enabled ()
       || cgraph_node::get (cfun->decl)->only_called_directly_p ())
     {
       /* Emit the patchable_area at the beginning of the function.  */
@@ -22883,7 +22752,7 @@ void
 aarch64_post_cfi_startproc (FILE *f, tree ignored ATTRIBUTE_UNUSED)
 {
   if (cfun->machine->frame.laid_out && aarch64_return_address_signing_enabled ()
-      && aarch64_ra_sign_key == AARCH64_KEY_B)
+      && aarch_ra_sign_key == AARCH_KEY_B)
 	asm_fprintf (f, "\t.cfi_b_key_frame\n");
 }
 
@@ -27292,10 +27161,10 @@ aarch64_file_end_indicate_exec_stack ()
   file_end_indicate_exec_stack ();
 
   unsigned feature_1_and = 0;
-  if (aarch64_bti_enabled ())
+  if (aarch_bti_enabled ())
     feature_1_and |= GNU_PROPERTY_AARCH64_FEATURE_1_BTI;
 
-  if (aarch64_ra_sign_scope != AARCH64_FUNCTION_NONE)
+  if (aarch_ra_sign_scope != AARCH_FUNCTION_NONE)
     feature_1_and |= GNU_PROPERTY_AARCH64_FEATURE_1_PAC;
 
   if (feature_1_and)
diff --git a/gcc/config/aarch64/aarch64.md b/gcc/config/aarch64/aarch64.md
index 2c13679..0b326d4 100644
--- a/gcc/config/aarch64/aarch64.md
+++ b/gcc/config/aarch64/aarch64.md
@@ -891,7 +891,7 @@
     if (aarch64_return_address_signing_enabled ()
 	&& (TARGET_PAUTH))
       {
-	if (aarch64_ra_sign_key == AARCH64_KEY_B)
+	if (aarch_ra_sign_key == AARCH_KEY_B)
 	  ret = "retab";
 	else
 	  ret = "retaa";
@@ -4457,8 +4457,9 @@
   {
     if (aarch64_sve_cnt_immediate (operands[1], <MODE>mode))
       std::swap (operands[1], operands[2]);
-    else if (!aarch64_sve_cnt_immediate (operands[2], <MODE>mode)
-	     && TARGET_CSSC)
+    else if (aarch64_sve_cnt_immediate (operands[2], <MODE>mode))
+      ;
+    else if (TARGET_CSSC)
       {
 	if (aarch64_uminmax_immediate (operands[1], <MODE>mode))
 	  std::swap (operands[1], operands[2]);
diff --git a/gcc/config/aarch64/aarch64.opt b/gcc/config/aarch64/aarch64.opt
index 070d7f1..137e506 100644
--- a/gcc/config/aarch64/aarch64.opt
+++ b/gcc/config/aarch64/aarch64.opt
@@ -21,6 +21,9 @@
 HeaderInclude
 config/aarch64/aarch64-opts.h
 
+HeaderInclude
+config/arm/aarch-common.h
+
 TargetVariable
 enum aarch64_processor selected_tune = aarch64_none
 
@@ -34,7 +37,7 @@ TargetVariable
 aarch64_feature_flags aarch64_isa_flags = 0
 
 TargetVariable
-unsigned aarch64_enable_bti = 2
+unsigned aarch_enable_bti = 2
 
 TargetVariable
 enum aarch64_key_type aarch64_ra_sign_key = AARCH64_KEY_A
@@ -164,21 +167,21 @@ Target RejectNegative Joined Var(aarch64_branch_protection_string) Save
 Use branch-protection features.
 
 msign-return-address=
-Target WarnRemoved RejectNegative Joined Enum(aarch64_ra_sign_scope_t) Var(aarch64_ra_sign_scope) Init(AARCH64_FUNCTION_NONE) Save
+Target WarnRemoved RejectNegative Joined Enum(aarch_ra_sign_scope_t) Var(aarch_ra_sign_scope) Init(AARCH_FUNCTION_NONE) Save
 Select return address signing scope.
 
 Enum
-Name(aarch64_ra_sign_scope_t) Type(enum aarch64_function_type)
+Name(aarch_ra_sign_scope_t) Type(enum aarch_function_type)
 Supported AArch64 return address signing scope (for use with -msign-return-address= option):
 
 EnumValue
-Enum(aarch64_ra_sign_scope_t) String(none) Value(AARCH64_FUNCTION_NONE)
+Enum(aarch_ra_sign_scope_t) String(none) Value(AARCH_FUNCTION_NONE)
 
 EnumValue
-Enum(aarch64_ra_sign_scope_t) String(non-leaf) Value(AARCH64_FUNCTION_NON_LEAF)
+Enum(aarch_ra_sign_scope_t) String(non-leaf) Value(AARCH_FUNCTION_NON_LEAF)
 
 EnumValue
-Enum(aarch64_ra_sign_scope_t) String(all) Value(AARCH64_FUNCTION_ALL)
+Enum(aarch_ra_sign_scope_t) String(all) Value(AARCH_FUNCTION_ALL)
 
 mlow-precision-recip-sqrt
 Target Var(flag_mrecip_low_precision_sqrt) Optimization
diff --git a/gcc/config/aarch64/arm_neon.h b/gcc/config/aarch64/arm_neon.h
index cdc2b63..eeec9f1 100644
--- a/gcc/config/aarch64/arm_neon.h
+++ b/gcc/config/aarch64/arm_neon.h
@@ -7496,7 +7496,7 @@ vqrdmlshs_laneq_s32 (int32_t __a, int32_t __b, int32x4_t __c, const int __d)
 #pragma GCC pop_options
 
 #pragma GCC push_options
-#pragma GCC target ("+nothing+crypto")
+#pragma GCC target ("+nothing+aes")
 /* vaes  */
 
 __extension__ extern __inline uint8x16_t
@@ -7526,6 +7526,22 @@ vaesimcq_u8 (uint8x16_t data)
 {
   return __builtin_aarch64_crypto_aesimcv16qi_uu (data);
 }
+
+__extension__ extern __inline poly128_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vmull_p64 (poly64_t __a, poly64_t __b)
+{
+  return
+    __builtin_aarch64_crypto_pmulldi_ppp (__a, __b);
+}
+
+__extension__ extern __inline poly128_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vmull_high_p64 (poly64x2_t __a, poly64x2_t __b)
+{
+  return __builtin_aarch64_crypto_pmullv2di_ppp (__a, __b);
+}
+
 #pragma GCC pop_options
 
 /* vcage  */
@@ -20772,7 +20788,7 @@ vrsrad_n_u64 (uint64_t __a, uint64_t __b, const int __c)
 }
 
 #pragma GCC push_options
-#pragma GCC target ("+nothing+crypto")
+#pragma GCC target ("+nothing+sha2")
 
 /* vsha1  */
 
@@ -20849,21 +20865,6 @@ vsha256su1q_u32 (uint32x4_t __tw0_3, uint32x4_t __w8_11, uint32x4_t __w12_15)
 						       __w12_15);
 }
 
-__extension__ extern __inline poly128_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_p64 (poly64_t __a, poly64_t __b)
-{
-  return
-    __builtin_aarch64_crypto_pmulldi_ppp (__a, __b);
-}
-
-__extension__ extern __inline poly128_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_high_p64 (poly64x2_t __a, poly64x2_t __b)
-{
-  return __builtin_aarch64_crypto_pmullv2di_ppp (__a, __b);
-}
-
 #pragma GCC pop_options
 
 /* vshl */
diff --git a/gcc/config/aarch64/t-aarch64 b/gcc/config/aarch64/t-aarch64
index dccf101..a9a244a 100644
--- a/gcc/config/aarch64/t-aarch64
+++ b/gcc/config/aarch64/t-aarch64
@@ -161,14 +161,14 @@ falkor-tag-collision-avoidance.o: \
 	$(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \
 		$(srcdir)/config/aarch64/falkor-tag-collision-avoidance.cc
 
-aarch64-bti-insert.o: $(srcdir)/config/aarch64/aarch64-bti-insert.cc \
+aarch-bti-insert.o: $(srcdir)/config/arm/aarch-bti-insert.cc \
     $(CONFIG_H) $(SYSTEM_H) $(TM_H) $(REGS_H) insn-config.h $(RTL_BASE_H) \
     dominance.h cfg.h cfganal.h $(BASIC_BLOCK_H) $(INSN_ATTR_H) $(RECOG_H) \
     output.h hash-map.h $(DF_H) $(OBSTACK_H) $(TARGET_H) $(RTL_H) \
     $(CONTEXT_H) $(TREE_PASS_H) regrename.h \
     $(srcdir)/config/aarch64/aarch64-protos.h
 	$(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \
-		$(srcdir)/config/aarch64/aarch64-bti-insert.cc
+		$(srcdir)/config/arm/aarch-bti-insert.cc
 
 aarch64-cc-fusion.o: $(srcdir)/config/aarch64/aarch64-cc-fusion.cc \
     $(CONFIG_H) $(SYSTEM_H) $(CORETYPES_H) $(BACKEND_H) $(RTL_H) $(DF_H) \
diff --git a/gcc/config/alpha/linux.h b/gcc/config/alpha/linux.h
index 9c3ad5a..7d2f0e8 100644
--- a/gcc/config/alpha/linux.h
+++ b/gcc/config/alpha/linux.h
@@ -106,7 +106,7 @@ along with GCC; see the file COPYING3.  If not see
 
 #undef	ENDFILE_SPEC
 #define ENDFILE_SPEC \
-  "%{Ofast|ffast-math|funsafe-math-optimizations:crtfastmath.o%s} \
+  "%{Ofast|ffast-math|funsafe-math-optimizations:%{!shared:crtfastmath.o%s}} \
    %{shared|pie:crtendS.o%s;:crtend.o%s} crtn.o%s"
 
 #define LINK_GCC_C_SEQUENCE_SPEC \
diff --git a/gcc/config/aarch64/aarch64-bti-insert.cc b/gcc/config/arm/aarch-bti-insert.cc
index f34201d..71a77e2 100644
--- a/gcc/config/aarch64/aarch64-bti-insert.cc
+++ b/gcc/config/arm/aarch-bti-insert.cc
@@ -42,10 +42,11 @@
 #include "tree-pass.h"
 #include "cgraph.h"
 
-/* This pass enables the support for Branch Target Identification Mechanism
-   for AArch64.  This is a new security feature introduced in ARMv8.5-A
-   archtitecture.  A BTI instruction is used to guard against the execution
-   of instructions which are not the intended target of an indirect branch.
+/* This pass enables the support for Branch Target Identification Mechanism for
+   Arm/AArch64.  This is a security feature introduced in ARMv8.5-A
+   architecture and ARMv8.1-M.  A BTI instruction is used to guard against the
+   execution of instructions which are not the intended target of an indirect
+   branch.
 
    Outside of a guarded memory region, a BTI instruction executes as a NOP.
    Within a guarded memory region any target of an indirect branch must be
@@ -53,7 +54,8 @@
    branch is triggered in a non-guarded memory region).  An incompatibility
    generates a Branch Target Exception.
 
-   The compatibility of the BTI instruction is as follows:
+   The compatibility of the BTI instruction is as follows (AArch64
+   examples):
    BTI j : Can be a target of any indirect jump (BR Xn).
    BTI c : Can be a target of any indirect call (BLR Xn and BR X16/X17).
    BTI jc: Can be a target of any indirect call or indirect jump.
@@ -90,47 +92,6 @@ const pass_data pass_data_insert_bti =
   0, /* todo_flags_finish.  */
 };
 
-/* Check if X (or any sub-rtx of X) is a PACIASP/PACIBSP instruction.  */
-static bool
-aarch64_pac_insn_p (rtx x)
-{
-  if (!INSN_P (x))
-    return false;
-
-  subrtx_var_iterator::array_type array;
-  FOR_EACH_SUBRTX_VAR (iter, array, PATTERN (x), ALL)
-    {
-      rtx sub = *iter;
-      if (sub && GET_CODE (sub) == UNSPEC)
-	{
-	  int unspec_val = XINT (sub, 1);
-	  switch (unspec_val)
-	    {
-	    case UNSPEC_PACIASP:
-            /* fall-through.  */
-            case UNSPEC_PACIBSP:
-	      return true;
-
-	    default:
-	      return false;
-	    }
-	  iter.skip_subrtxes ();
-	}
-    }
-  return false;
-}
-
-/* Check if INSN is a BTI J insn.  */
-static bool
-aarch64_bti_j_insn_p (rtx_insn *insn)
-{
-  if (!insn || !INSN_P (insn))
-    return false;
-
-  rtx pat = PATTERN (insn);
-  return GET_CODE (pat) == UNSPEC_VOLATILE && XINT (pat, 1) == UNSPECV_BTI_J;
-}
-
 /* Insert the BTI instruction.  */
 /* This is implemented as a late RTL pass that runs before branch
    shortening and does the following.  */
@@ -155,7 +116,7 @@ rest_of_insert_bti (void)
 	       && (LABEL_PRESERVE_P (insn)
 		   || bb->flags & BB_NON_LOCAL_GOTO_TARGET))
 	    {
-	      bti_insn = gen_bti_j ();
+	      bti_insn = aarch_gen_bti_j ();
 	      emit_insn_after (bti_insn, insn);
 	      continue;
 	    }
@@ -177,10 +138,10 @@ rest_of_insert_bti (void)
 		    {
 		      label = as_a <rtx_insn *> (XEXP (RTVEC_ELT (vec, j), 0));
 		      rtx_insn *next = next_nonnote_nondebug_insn (label);
-		      if (aarch64_bti_j_insn_p (next))
+		      if (aarch_bti_j_insn_p (next))
 			continue;
 
-		      bti_insn = gen_bti_j ();
+		      bti_insn = aarch_gen_bti_j ();
 		      emit_insn_after (bti_insn, label);
 		    }
 		}
@@ -191,7 +152,7 @@ rest_of_insert_bti (void)
 	     will return.  */
 	  if (CALL_P (insn) && (find_reg_note (insn, REG_SETJMP, NULL)))
 	    {
-	      bti_insn = gen_bti_j ();
+	      bti_insn = aarch_gen_bti_j ();
 	      emit_insn_after (bti_insn, insn);
 	      continue;
 	    }
@@ -207,9 +168,9 @@ rest_of_insert_bti (void)
     {
       bb = ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb;
       insn = BB_HEAD (bb);
-      if (!aarch64_pac_insn_p (get_first_nonnote_insn ()))
+      if (!aarch_pac_insn_p (get_first_nonnote_insn ()))
 	{
-	  bti_insn = gen_bti_c ();
+	  bti_insn = aarch_gen_bti_c ();
 	  emit_insn_before (bti_insn, insn);
 	}
     }
@@ -229,7 +190,12 @@ public:
   /* opt_pass methods: */
   virtual bool gate (function *)
     {
-      return aarch64_bti_enabled ();
+      if (aarch_bti_enabled ())
+        {
+          aarch_bti_arch_check ();
+          return true;
+        }
+      return false;
     }
 
   virtual unsigned int execute (function *)
diff --git a/gcc/config/arm/aarch-common-protos.h b/gcc/config/arm/aarch-common-protos.h
index 5ea0ad2..f8cb656 100644
--- a/gcc/config/arm/aarch-common-protos.h
+++ b/gcc/config/arm/aarch-common-protos.h
@@ -42,6 +42,12 @@ extern int arm_no_early_alu_shift_value_dep (rtx, rtx);
 extern int arm_no_early_mul_dep (rtx, rtx);
 extern int arm_no_early_store_addr_dep (rtx, rtx);
 extern bool arm_rtx_shift_left_p (rtx);
+extern void aarch_bti_arch_check (void);
+extern bool aarch_bti_enabled (void);
+extern bool aarch_bti_j_insn_p (rtx_insn *);
+extern bool aarch_pac_insn_p (rtx);
+extern rtx aarch_gen_bti_c (void);
+extern rtx aarch_gen_bti_j (void);
 
 /* RTX cost table definitions.  These are used when tuning for speed rather
    than for size and should reflect the _additional_ cost over the cost
@@ -153,4 +159,10 @@ rtx_insn *arm_md_asm_adjust (vec<rtx> &outputs, vec<rtx> & /*inputs*/,
 			     vec<rtx> &clobbers, HARD_REG_SET &clobbered_regs,
 			     location_t loc);
 
+/* Parsing routine for branch-protection common to AArch64 and Arm.  */
+enum aarch_parse_opt_result aarch_parse_branch_protection (const char*, char**);
+
+/* Validation routine for branch-protection common to AArch64 and Arm.  */
+bool aarch_validate_mbranch_protection (const char *);
+
 #endif /* GCC_AARCH_COMMON_PROTOS_H */
diff --git a/gcc/config/arm/aarch-common.cc b/gcc/config/arm/aarch-common.cc
index 40bb28b..27e6c8f 100644
--- a/gcc/config/arm/aarch-common.cc
+++ b/gcc/config/arm/aarch-common.cc
@@ -36,6 +36,7 @@
 #include "expr.h"
 #include "function.h"
 #include "emit-rtl.h"
+#include "aarch-common.h"
 
 /* Return TRUE if X is either an arithmetic shift left, or
    is a multiplication by a power of two.  */
@@ -657,3 +658,187 @@ arm_md_asm_adjust (vec<rtx> &outputs, vec<rtx> & /*inputs*/,
 
   return saw_asm_flag ? seq : NULL;
 }
+
+#define BRANCH_PROTECT_STR_MAX 255
+extern char *accepted_branch_protection_string;
+extern enum aarch_key_type aarch_ra_sign_key;
+
+static enum aarch_parse_opt_result
+aarch_handle_no_branch_protection (char* str, char* rest)
+{
+  aarch_ra_sign_scope = AARCH_FUNCTION_NONE;
+  aarch_enable_bti = 0;
+  if (rest)
+    {
+      error ("unexpected %<%s%> after %<%s%>", rest, str);
+      return AARCH_PARSE_INVALID_FEATURE;
+    }
+  return AARCH_PARSE_OK;
+}
+
+static enum aarch_parse_opt_result
+aarch_handle_standard_branch_protection (char* str, char* rest)
+{
+  aarch_ra_sign_scope = AARCH_FUNCTION_NON_LEAF;
+  aarch_ra_sign_key = AARCH_KEY_A;
+  aarch_enable_bti = 1;
+  if (rest)
+    {
+      error ("unexpected %<%s%> after %<%s%>", rest, str);
+      return AARCH_PARSE_INVALID_FEATURE;
+    }
+  return AARCH_PARSE_OK;
+}
+
+static enum aarch_parse_opt_result
+aarch_handle_pac_ret_protection (char* str ATTRIBUTE_UNUSED,
+				 char* rest ATTRIBUTE_UNUSED)
+{
+  aarch_ra_sign_scope = AARCH_FUNCTION_NON_LEAF;
+  aarch_ra_sign_key = AARCH_KEY_A;
+  return AARCH_PARSE_OK;
+}
+
+static enum aarch_parse_opt_result
+aarch_handle_pac_ret_leaf (char* str ATTRIBUTE_UNUSED,
+			   char* rest ATTRIBUTE_UNUSED)
+{
+  aarch_ra_sign_scope = AARCH_FUNCTION_ALL;
+  return AARCH_PARSE_OK;
+}
+
+static enum aarch_parse_opt_result
+aarch_handle_pac_ret_b_key (char* str ATTRIBUTE_UNUSED,
+			    char* rest ATTRIBUTE_UNUSED)
+{
+  aarch_ra_sign_key = AARCH_KEY_B;
+  return AARCH_PARSE_OK;
+}
+
+static enum aarch_parse_opt_result
+aarch_handle_bti_protection (char* str ATTRIBUTE_UNUSED,
+			     char* rest ATTRIBUTE_UNUSED)
+{
+  aarch_enable_bti = 1;
+  return AARCH_PARSE_OK;
+}
+
+static const struct aarch_branch_protect_type aarch_pac_ret_subtypes[] = {
+  { "leaf", aarch_handle_pac_ret_leaf, NULL, 0 },
+  { "b-key", aarch_handle_pac_ret_b_key, NULL, 0 },
+  { NULL, NULL, NULL, 0 }
+};
+
+static const struct aarch_branch_protect_type aarch_branch_protect_types[] = {
+  { "none", aarch_handle_no_branch_protection, NULL, 0 },
+  { "standard", aarch_handle_standard_branch_protection, NULL, 0 },
+  { "pac-ret", aarch_handle_pac_ret_protection, aarch_pac_ret_subtypes,
+    ARRAY_SIZE (aarch_pac_ret_subtypes) },
+  { "bti", aarch_handle_bti_protection, NULL, 0 },
+  { NULL, NULL, NULL, 0 }
+};
+
+/* Parses CONST_STR for branch protection features specified in
+   aarch64_branch_protect_types, and set any global variables required.  Returns
+   the parsing result and assigns LAST_STR to the last processed token from
+   CONST_STR so that it can be used for error reporting.  */
+
+enum aarch_parse_opt_result
+aarch_parse_branch_protection (const char *const_str, char** last_str)
+{
+  char *str_root = xstrdup (const_str);
+  char* token_save = NULL;
+  char *str = strtok_r (str_root, "+", &token_save);
+  enum aarch_parse_opt_result res = AARCH_PARSE_OK;
+  if (!str)
+    res = AARCH_PARSE_MISSING_ARG;
+  else
+    {
+      char *next_str = strtok_r (NULL, "+", &token_save);
+      /* Reset the branch protection features to their defaults.  */
+      aarch_handle_no_branch_protection (NULL, NULL);
+
+      while (str && res == AARCH_PARSE_OK)
+	{
+	  const aarch_branch_protect_type* type = aarch_branch_protect_types;
+	  bool found = false;
+	  /* Search for this type.  */
+	  while (type && type->name && !found && res == AARCH_PARSE_OK)
+	    {
+	      if (strcmp (str, type->name) == 0)
+		{
+		  found = true;
+		  res = type->handler (str, next_str);
+		  str = next_str;
+		  next_str = strtok_r (NULL, "+", &token_save);
+		}
+	      else
+		type++;
+	    }
+	  if (found && res == AARCH_PARSE_OK)
+	    {
+	      bool found_subtype = true;
+	      /* Loop through each token until we find one that isn't a
+		 subtype.  */
+	      while (found_subtype)
+		{
+		  found_subtype = false;
+		  const aarch_branch_protect_type *subtype = type->subtypes;
+		  /* Search for the subtype.  */
+		  while (str && subtype && subtype->name && !found_subtype
+			  && res == AARCH_PARSE_OK)
+		    {
+		      if (strcmp (str, subtype->name) == 0)
+			{
+			  found_subtype = true;
+			  res = subtype->handler (str, next_str);
+			  str = next_str;
+			  next_str = strtok_r (NULL, "+", &token_save);
+			}
+		      else
+			subtype++;
+		    }
+		}
+	    }
+	  else if (!found)
+	    res = AARCH_PARSE_INVALID_ARG;
+	}
+    }
+  /* Copy the last processed token into the argument to pass it back.
+    Used by option and attribute validation to print the offending token.  */
+  if (last_str)
+    {
+      if (str)
+	strcpy (*last_str, str);
+      else
+	*last_str = NULL;
+    }
+
+  if (res == AARCH_PARSE_OK)
+    {
+      /* If needed, alloc the accepted string then copy in const_str.
+	Used by override_option_after_change_1.  */
+      if (!accepted_branch_protection_string)
+	accepted_branch_protection_string
+	  = (char *) xmalloc (BRANCH_PROTECT_STR_MAX + 1);
+      strncpy (accepted_branch_protection_string, const_str,
+	       BRANCH_PROTECT_STR_MAX + 1);
+      /* Forcibly null-terminate.  */
+      accepted_branch_protection_string[BRANCH_PROTECT_STR_MAX] = '\0';
+    }
+  return res;
+}
+
+bool
+aarch_validate_mbranch_protection (const char *const_str)
+{
+  char *str = (char *) xmalloc (strlen (const_str));
+  enum aarch_parse_opt_result res =
+    aarch_parse_branch_protection (const_str, &str);
+  if (res == AARCH_PARSE_INVALID_ARG)
+    error ("invalid argument %<%s%> for %<-mbranch-protection=%>", str);
+  else if (res == AARCH_PARSE_MISSING_ARG)
+    error ("missing argument for %<-mbranch-protection=%>");
+  free (str);
+  return res == AARCH_PARSE_OK;
+}
diff --git a/gcc/config/arm/aarch-common.h b/gcc/config/arm/aarch-common.h
new file mode 100644
index 0000000..c6a67f0
--- /dev/null
+++ b/gcc/config/arm/aarch-common.h
@@ -0,0 +1,73 @@
+/* Types shared between arm and aarch64.
+
+   Copyright (C) 2009-2021 Free Software Foundation, Inc.
+   Contributed by Arm Ltd.
+
+   This file is part of GCC.
+
+   GCC is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published
+   by the Free Software Foundation; either version 3, or (at your
+   option) any later version.
+
+   GCC is distributed in the hope that it will be useful, but WITHOUT
+   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
+   License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with GCC; see the file COPYING3.  If not see
+   <http://www.gnu.org/licenses/>.  */
+
+#ifndef GCC_AARCH_COMMON_H
+#define GCC_AARCH_COMMON_H
+
+/* Enum describing the various ways that the
+   aarch*_parse_{arch,tune,cpu,extension} functions can fail.
+   This way their callers can choose what kind of error to give.  */
+
+enum aarch_parse_opt_result
+{
+  AARCH_PARSE_OK,			/* Parsing was successful.  */
+  AARCH_PARSE_MISSING_ARG,		/* Missing argument.  */
+  AARCH_PARSE_INVALID_FEATURE,		/* Invalid feature modifier.  */
+  AARCH_PARSE_INVALID_ARG		/* Invalid arch, tune, cpu arg.  */
+};
+
+/* Function types -msign-return-address should sign.  */
+enum aarch_function_type {
+  /* Don't sign any function.  */
+  AARCH_FUNCTION_NONE,
+  /* Non-leaf functions.  */
+  AARCH_FUNCTION_NON_LEAF,
+  /* All functions.  */
+  AARCH_FUNCTION_ALL
+};
+
+/* The key type that -msign-return-address should use.  */
+enum aarch_key_type {
+  AARCH_KEY_A,
+  AARCH_KEY_B
+};
+
+struct aarch_branch_protect_type
+{
+  /* The type's name that the user passes to the branch-protection option
+     string.  */
+  const char* name;
+  /* Function to handle the protection type and set global variables.
+     First argument is the string token corresponding with this type and the
+     second argument is the next token in the option string.
+     Return values:
+     * AARCH_PARSE_OK: Handling was sucessful.
+     * AARCH_INVALID_ARG: The type is invalid in this context and the caller
+     should print an error.
+     * AARCH_INVALID_FEATURE: The type is invalid and the handler prints its
+     own error.  */
+  enum aarch_parse_opt_result (*handler)(char*, char*);
+  /* A list of types that can follow this type in the option string.  */
+  const struct aarch_branch_protect_type* subtypes;
+  unsigned int num_subtypes;
+};
+
+#endif /* GCC_AARCH_COMMON_H */
diff --git a/gcc/config/arm/aout.h b/gcc/config/arm/aout.h
index b8f8eb0..57c3b9b 100644
--- a/gcc/config/arm/aout.h
+++ b/gcc/config/arm/aout.h
@@ -74,7 +74,8 @@
   "wr8",   "wr9",   "wr10",  "wr11",				\
   "wr12",  "wr13",  "wr14",  "wr15",				\
   "wcgr0", "wcgr1", "wcgr2", "wcgr3",				\
-  "cc", "vfpcc", "sfp", "afp", "apsrq", "apsrge", "p0"		\
+  "cc", "vfpcc", "sfp", "afp", "apsrq", "apsrge", "p0",		\
+  "ra_auth_code"						\
 }
 #endif
 
diff --git a/gcc/config/arm/arm-c.cc b/gcc/config/arm/arm-c.cc
index df86342..59c0d8c 100644
--- a/gcc/config/arm/arm-c.cc
+++ b/gcc/config/arm/arm-c.cc
@@ -214,6 +214,24 @@ arm_cpu_builtins (struct cpp_reader* pfile)
   def_or_undef_macro (pfile, "__ARM_FEATURE_COMPLEX", TARGET_COMPLEX);
   def_or_undef_macro (pfile, "__ARM_32BIT_STATE", TARGET_32BIT);
 
+  def_or_undef_macro (pfile, "__ARM_FEATURE_PAUTH", TARGET_HAVE_PACBTI);
+  def_or_undef_macro (pfile, "__ARM_FEATURE_BTI", TARGET_HAVE_PACBTI);
+  def_or_undef_macro (pfile, "__ARM_FEATURE_BTI_DEFAULT",
+		      aarch_enable_bti == 1);
+
+  cpp_undef (pfile, "__ARM_FEATURE_PAC_DEFAULT");
+  if (aarch_ra_sign_scope != AARCH_FUNCTION_NONE)
+  {
+    unsigned int pac = 1;
+
+    gcc_assert (aarch_ra_sign_key == AARCH_KEY_A);
+
+    if (aarch_ra_sign_scope == AARCH_FUNCTION_ALL)
+      pac |= 0x4;
+
+    builtin_define_with_int_value ("__ARM_FEATURE_PAC_DEFAULT", pac);
+  }
+
   cpp_undef (pfile, "__ARM_FEATURE_MVE");
   if (TARGET_HAVE_MVE && TARGET_HAVE_MVE_FLOAT)
     {
diff --git a/gcc/config/arm/arm-cpus.in b/gcc/config/arm/arm-cpus.in
index 579cf35..f1fa3fa 100644
--- a/gcc/config/arm/arm-cpus.in
+++ b/gcc/config/arm/arm-cpus.in
@@ -229,6 +229,10 @@ define feature cdecp5
 define feature cdecp6
 define feature cdecp7
 
+# M-profile control flow integrity extensions (PAC/AUT/BTI).
+# Optional from Armv8.1-M Mainline.
+define feature pacbti
+
 # Feature groups.  Conventionally all (or mostly) upper case.
 # ALL_FPU lists all the feature bits associated with the floating-point
 # unit; these will all be removed if the floating-point unit is disabled
@@ -743,6 +747,7 @@ begin arch armv8.1-m.main
  isa ARMv8_1m_main
 # fp => FPv5-sp-d16; fp.dp => FPv5-d16
  option dsp add armv7em
+ option pacbti add pacbti
  option fp add FPv5 fp16
  option fp.dp add FPv5 FP_DBL fp16
  option nofp remove ALL_FP
@@ -1667,6 +1672,21 @@ begin cpu star-mc1
  costs v7m
 end cpu star-mc1
 
+begin cpu cortex-m85
+ cname cortexm85
+ tune flags LDSCHED
+ architecture armv8.1-m.main+pacbti+mve.fp+fp.dp
+ option nopacbti remove pacbti
+ option nomve.fp remove mve_float
+ option nomve remove mve mve_float
+ option nofp remove ALL_FP mve_float
+ option nodsp remove MVE mve_float
+ isa quirk_no_asmcpu quirk_vlldm
+ costs v7m
+ part 0xd23
+ vendor 41
+end cpu cortex-m85
+
 # V8 R-profile implementations.
 begin cpu cortex-r52
  cname cortexr52
diff --git a/gcc/config/arm/arm-mlib.h b/gcc/config/arm/arm-mlib.h
new file mode 100644
index 0000000..02cfba0
--- /dev/null
+++ b/gcc/config/arm/arm-mlib.h
@@ -0,0 +1,22 @@
+/* Arm multilib default option include file.
+
+   Copyright (C) 2023 Free Software Foundation, Inc.
+   Contributed by Arm.
+
+   This file is part of GCC.
+
+   GCC is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published
+   by the Free Software Foundation; either version 3, or (at your
+   option) any later version.
+
+   GCC is distributed in the hope that it will be useful, but WITHOUT
+   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
+   License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with GCC; see the file COPYING3.  If not see
+   <http://www.gnu.org/licenses/>.  */
+
+#define MULTILIB_DEFAULTS { "mbranch-protection=none" }
diff --git a/gcc/config/arm/arm-passes.def b/gcc/config/arm/arm-passes.def
new file mode 100644
index 0000000..71d6b56
--- /dev/null
+++ b/gcc/config/arm/arm-passes.def
@@ -0,0 +1,21 @@
+/* Arm-specific passes declarations.
+   Copyright (C) 2022 Free Software Foundation, Inc.
+   Contributed by Arm Ltd.
+
+   This file is part of GCC.
+
+   GCC is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3, or (at your option)
+   any later version.
+
+   GCC is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with GCC; see the file COPYING3.  If not see
+   <http://www.gnu.org/licenses/>.  */
+
+INSERT_PASS_BEFORE (pass_shorten_branches, 1, pass_insert_bti);
diff --git a/gcc/config/arm/arm-protos.h b/gcc/config/arm/arm-protos.h
index 95918dd..aea472b 100644
--- a/gcc/config/arm/arm-protos.h
+++ b/gcc/config/arm/arm-protos.h
@@ -24,6 +24,8 @@
 
 #include "sbitmap.h"
 
+rtl_opt_pass *make_pass_insert_bti (gcc::context *ctxt);
+
 extern enum unwind_info_type arm_except_unwind_info (struct gcc_options *);
 extern int use_return_insn (int, rtx);
 extern bool use_simple_return_p (void);
@@ -379,6 +381,7 @@ extern int vfp3_const_double_for_bits (rtx);
 extern void arm_emit_coreregs_64bit_shift (enum rtx_code, rtx, rtx, rtx, rtx,
 					   rtx);
 extern bool arm_fusion_enabled_p (tune_params::fuse_ops);
+extern bool arm_current_function_pac_enabled_p (void);
 extern bool arm_valid_symbolic_address_p (rtx);
 extern bool arm_validize_comparison (rtx *, rtx *, rtx *);
 extern bool arm_expand_vector_compare (rtx, rtx_code, rtx, rtx, bool);
@@ -582,6 +585,8 @@ struct cpu_option
 extern const arch_option all_architectures[];
 extern const cpu_option all_cores[];
 
+extern enum aarch_key_type aarch_ra_sign_key;
+
 const cpu_option *arm_parse_cpu_option_name (const cpu_option *, const char *,
 					     const char *, bool = true);
 const arch_option *arm_parse_arch_option_name (const arch_option *,
diff --git a/gcc/config/arm/arm-tables.opt b/gcc/config/arm/arm-tables.opt
index b3ab72f..88909c2 100644
--- a/gcc/config/arm/arm-tables.opt
+++ b/gcc/config/arm/arm-tables.opt
@@ -289,6 +289,9 @@ EnumValue
 Enum(processor_type) String(star-mc1) Value( TARGET_CPU_starmc1)
 
 EnumValue
+Enum(processor_type) String(cortex-m85) Value( TARGET_CPU_cortexm85)
+
+EnumValue
 Enum(processor_type) String(cortex-r52) Value( TARGET_CPU_cortexr52)
 
 EnumValue
diff --git a/gcc/config/arm/arm-tune.md b/gcc/config/arm/arm-tune.md
index 29ca2b4..5e95e82 100644
--- a/gcc/config/arm/arm-tune.md
+++ b/gcc/config/arm/arm-tune.md
@@ -46,9 +46,10 @@
 	cortexa73cortexa53,cortexa55,cortexa75,
 	cortexa76,cortexa76ae,cortexa77,
 	cortexa78,cortexa78ae,cortexa78c,
-	cortexa710,cortexx1,cortexx1c,neoversen1,
-	cortexa75cortexa55,cortexa76cortexa55,neoversev1,
-	neoversen2,cortexm23,cortexm33,
-	cortexm35p,cortexm55,starmc1,
-	cortexr52,cortexr52plus"
+	cortexa710,cortexx1,cortexx1c,
+	neoversen1,cortexa75cortexa55,cortexa76cortexa55,
+	neoversev1,neoversen2,cortexm23,
+	cortexm33,cortexm35p,cortexm55,
+	starmc1,cortexm85,cortexr52,
+	cortexr52plus"
 	(const (symbol_ref "((enum attr_tune) arm_tune)")))
diff --git a/gcc/config/arm/arm.cc b/gcc/config/arm/arm.cc
index 3f17118..efc4834 100644
--- a/gcc/config/arm/arm.cc
+++ b/gcc/config/arm/arm.cc
@@ -72,6 +72,8 @@
 #include "selftest.h"
 #include "tree-vectorizer.h"
 #include "opts.h"
+#include "aarch-common.h"
+#include "aarch-common-protos.h"
 
 /* This file should be included last.  */
 #include "target-def.h"
@@ -921,6 +923,11 @@ int arm_arch8_3 = 0;
 
 /* Nonzero if this chip supports the ARM Architecture 8.4 extensions.  */
 int arm_arch8_4 = 0;
+
+/* Nonzero if this chip supports the ARM Architecture 8-M Mainline
+   extensions.  */
+int arm_arch8m_main = 0;
+
 /* Nonzero if this chip supports the ARM Architecture 8.1-M Mainline
    extensions.  */
 int arm_arch8_1m_main = 0;
@@ -2413,6 +2420,11 @@ const struct tune_params arm_fa726te_tune =
   tune_params::SCHED_AUTOPREF_OFF
 };
 
+/* Key type for Pointer Authentication extension.  */
+enum aarch_key_type aarch_ra_sign_key = AARCH_KEY_A;
+
+char *accepted_branch_protection_string = NULL;
+
 /* Auto-generated CPU, FPU and architecture tables.  */
 #include "arm-cpu-data.h"
 
@@ -3198,6 +3210,15 @@ arm_option_override_internal (struct gcc_options *opts,
       arm_stack_protector_guard_offset = offs;
     }
 
+  if (arm_current_function_pac_enabled_p ())
+    {
+      if (!arm_arch8m_main)
+        error ("This architecture does not support branch protection "
+               "instructions");
+      if (TARGET_TPCS_FRAME)
+        sorry ("Return address signing is not supported with %<-mtpcs-frame%>.");
+    }
+
 #ifdef SUBTARGET_OVERRIDE_INTERNAL_OPTIONS
   SUBTARGET_OVERRIDE_INTERNAL_OPTIONS;
 #endif
@@ -3252,6 +3273,17 @@ arm_configure_build_target (struct arm_build_target *target,
       tune_opts = strchr (opts->x_arm_tune_string, '+');
     }
 
+  if (opts->x_arm_branch_protection_string)
+    {
+      aarch_validate_mbranch_protection (opts->x_arm_branch_protection_string);
+
+      if (aarch_ra_sign_key != AARCH_KEY_A)
+	{
+	  warning (0, "invalid key type for %<-mbranch-protection=%>");
+	  aarch_ra_sign_key = AARCH_KEY_A;
+	}
+    }
+
   if (arm_selected_arch)
     {
       arm_initialize_isa (target->isa, arm_selected_arch->common.isa_bits);
@@ -3833,6 +3865,7 @@ arm_option_reconfigure_globals (void)
   arm_arch_arm_hwdiv = bitmap_bit_p (arm_active_target.isa, isa_bit_adiv);
   arm_arch_crc = bitmap_bit_p (arm_active_target.isa, isa_bit_crc32);
   arm_arch_cmse = bitmap_bit_p (arm_active_target.isa, isa_bit_cmse);
+  arm_arch8m_main = arm_arch7 && arm_arch_cmse;
   arm_arch_lpae = bitmap_bit_p (arm_active_target.isa, isa_bit_lpae);
   arm_arch_i8mm = bitmap_bit_p (arm_active_target.isa, isa_bit_i8mm);
   arm_arch_bf16 = bitmap_bit_p (arm_active_target.isa, isa_bit_bf16);
@@ -4332,6 +4365,12 @@ use_return_insn (int iscond, rtx sibling)
   if (!reload_completed)
     return 0;
 
+  /* Never use a return instruction when return address signing
+     mechanism is enabled as it requires more than one
+     instruction.  */
+  if (arm_current_function_pac_enabled_p ())
+    return 0;
+
   func_type = arm_current_func_type ();
 
   /* Naked, volatile and stack alignment functions need special
@@ -21227,6 +21266,9 @@ arm_compute_save_core_reg_mask (void)
 
   save_reg_mask |= arm_compute_save_reg0_reg12_mask ();
 
+  if (arm_current_function_pac_enabled_p ())
+    save_reg_mask |= 1 << IP_REGNUM;
+
   /* Decide if we need to save the link register.
      Interrupt routines have their own banked link register,
      so they never need to save it.
@@ -22230,7 +22272,33 @@ emit_multi_reg_push (unsigned long mask, unsigned long dwarf_regs_mask)
     {
       if (mask & (1 << i))
 	{
-	  reg = gen_rtx_REG (SImode, i);
+	  /* NOTE: Dwarf code emitter handle reg-reg copies correctly and in the
+	     following example reg-reg copy of SP to IP register is handled
+	     through .cfi_def_cfa_register directive and the .cfi_offset
+	     directive for IP register is skipped by dwarf code emitter.
+	     Example:
+		mov     ip, sp
+		.cfi_def_cfa_register 12
+		push    {fp, ip, lr, pc}
+		.cfi_offset 11, -16
+		.cfi_offset 13, -12
+		.cfi_offset 14, -8
+
+	     Where as Arm-specific .save directive handling is different to that
+	     of dwarf code emitter and it doesn't consider reg-reg copies while
+	     updating the register list.  When PACBTI is enabled we manually
+	     updated the .save directive register list to use "ra_auth_code"
+	     (pseduo register 143) instead of IP register as shown in following
+	     pseduo code.
+	     Example:
+		pacbti  ip, lr, sp
+		.cfi_register 143, 12
+		push    {r3, r7, ip, lr}
+		.save {r3, r7, ra_auth_code, lr}
+	  */
+	  rtx dwarf_reg = reg = gen_rtx_REG (SImode, i);
+	  if (arm_current_function_pac_enabled_p () && i == IP_REGNUM)
+	    dwarf_reg = gen_rtx_REG (SImode, RA_AUTH_CODE);
 
 	  XVECEXP (par, 0, 0)
 	    = gen_rtx_SET (gen_frame_mem
@@ -22248,7 +22316,7 @@ emit_multi_reg_push (unsigned long mask, unsigned long dwarf_regs_mask)
 	  if (dwarf_regs_mask & (1 << i))
 	    {
 	      tmp = gen_rtx_SET (gen_frame_mem (SImode, stack_pointer_rtx),
-				 reg);
+				 dwarf_reg);
 	      RTX_FRAME_RELATED_P (tmp) = 1;
 	      XVECEXP (dwarf, 0, dwarf_par_index++) = tmp;
 	    }
@@ -22261,7 +22329,9 @@ emit_multi_reg_push (unsigned long mask, unsigned long dwarf_regs_mask)
     {
       if (mask & (1 << i))
 	{
-	  reg = gen_rtx_REG (SImode, i);
+	  rtx dwarf_reg = reg = gen_rtx_REG (SImode, i);
+	  if (arm_current_function_pac_enabled_p () && i == IP_REGNUM)
+	    dwarf_reg = gen_rtx_REG (SImode, RA_AUTH_CODE);
 
 	  XVECEXP (par, 0, j) = gen_rtx_USE (VOIDmode, reg);
 
@@ -22272,7 +22342,7 @@ emit_multi_reg_push (unsigned long mask, unsigned long dwarf_regs_mask)
 			       (SImode,
 				plus_constant (Pmode, stack_pointer_rtx,
 					       4 * j)),
-			       reg);
+			       dwarf_reg);
 	      RTX_FRAME_RELATED_P (tmp) = 1;
 	      XVECEXP (dwarf, 0, dwarf_par_index++) = tmp;
 	    }
@@ -22357,7 +22427,9 @@ arm_emit_multi_reg_pop (unsigned long saved_regs_mask)
   for (j = 0, i = 0; j < num_regs; i++)
     if (saved_regs_mask & (1 << i))
       {
-        reg = gen_rtx_REG (SImode, i);
+	rtx dwarf_reg = reg = gen_rtx_REG (SImode, i);
+	if (arm_current_function_pac_enabled_p () && i == IP_REGNUM)
+	  dwarf_reg = gen_rtx_REG (SImode, RA_AUTH_CODE);
         if ((num_regs == 1) && emit_update && !return_in_pc)
           {
             /* Emit single load with writeback.  */
@@ -22365,7 +22437,8 @@ arm_emit_multi_reg_pop (unsigned long saved_regs_mask)
                                  gen_rtx_POST_INC (Pmode,
                                                    stack_pointer_rtx));
             tmp = emit_insn (gen_rtx_SET (reg, tmp));
-            REG_NOTES (tmp) = alloc_reg_note (REG_CFA_RESTORE, reg, dwarf);
+	    REG_NOTES (tmp) = alloc_reg_note (REG_CFA_RESTORE, dwarf_reg,
+					      dwarf);
             return;
           }
 
@@ -22379,7 +22452,7 @@ arm_emit_multi_reg_pop (unsigned long saved_regs_mask)
         /* We need to maintain a sequence for DWARF info too.  As dwarf info
            should not have PC, skip PC.  */
         if (i != PC_REGNUM)
-          dwarf = alloc_reg_note (REG_CFA_RESTORE, reg, dwarf);
+	  dwarf = alloc_reg_note (REG_CFA_RESTORE, dwarf_reg, dwarf);
 
         j++;
       }
@@ -23518,12 +23591,13 @@ arm_expand_prologue (void)
 
   /* The static chain register is the same as the IP register.  If it is
      clobbered when creating the frame, we need to save and restore it.  */
-  clobber_ip = IS_NESTED (func_type)
-	       && ((TARGET_APCS_FRAME && frame_pointer_needed && TARGET_ARM)
-		   || ((flag_stack_check == STATIC_BUILTIN_STACK_CHECK
-			|| flag_stack_clash_protection)
-		       && !df_regs_ever_live_p (LR_REGNUM)
-		       && arm_r3_live_at_start_p ()));
+  clobber_ip = (IS_NESTED (func_type)
+                && (((TARGET_APCS_FRAME && frame_pointer_needed && TARGET_ARM)
+                     || ((flag_stack_check == STATIC_BUILTIN_STACK_CHECK
+                          || flag_stack_clash_protection)
+                         && !df_regs_ever_live_p (LR_REGNUM)
+                         && arm_r3_live_at_start_p ()))
+                    || arm_current_function_pac_enabled_p ()));
 
   /* Find somewhere to store IP whilst the frame is being created.
      We try the following places in order:
@@ -23548,7 +23622,6 @@ arm_expand_prologue (void)
 	{
 	  rtx addr, dwarf;
 
-	  gcc_assert(arm_compute_static_chain_stack_bytes() == 4);
 	  saved_regs += 4;
 
 	  addr = gen_rtx_PRE_DEC (Pmode, stack_pointer_rtx);
@@ -23561,6 +23634,8 @@ arm_expand_prologue (void)
 					      -fp_offset));
 	  RTX_FRAME_RELATED_P (insn) = 1;
 	  add_reg_note (insn, REG_FRAME_RELATED_EXPR, dwarf);
+	  if (arm_current_function_pac_enabled_p ())
+	    cfun->machine->pacspval_needed = 1;
 	}
       else
 	{
@@ -23596,9 +23671,26 @@ arm_expand_prologue (void)
 	  RTX_FRAME_RELATED_P (insn) = 1;
 	  fp_offset = args_to_push;
 	  args_to_push = 0;
+	  if (arm_current_function_pac_enabled_p ())
+	    cfun->machine->pacspval_needed = 1;
 	}
     }
 
+  if (arm_current_function_pac_enabled_p ())
+    {
+      /* If IP was clobbered we only emit a PAC instruction as the BTI
+         one will be added before the push of the clobbered IP (if
+         necessary) by the bti pass.  */
+      if (aarch_bti_enabled () && !clobber_ip)
+	insn = emit_insn (gen_pacbti_nop ());
+      else
+	insn = emit_insn (gen_pac_nop ());
+
+      rtx dwarf = gen_rtx_SET (ip_rtx, gen_rtx_REG (SImode, RA_AUTH_CODE));
+      RTX_FRAME_RELATED_P (insn) = 1;
+      add_reg_note (insn, REG_CFA_REGISTER, dwarf);
+    }
+
   if (TARGET_APCS_FRAME && frame_pointer_needed && TARGET_ARM)
     {
       if (IS_INTERRUPT (func_type))
@@ -25678,6 +25770,9 @@ arm_regno_class (int regno)
   if (IS_VPR_REGNUM (regno))
     return VPR_REG;
 
+  if (IS_PAC_REGNUM (regno))
+    return PAC_REG;
+
   if (TARGET_THUMB1)
     {
       if (regno == STACK_POINTER_REGNUM)
@@ -26838,6 +26933,7 @@ arm_init_machine_status (void)
   machine->func_type = ARM_FT_UNKNOWN;
 #endif
   machine->static_chain_stack_bytes = -1;
+  machine->pacspval_needed = 0;
   return machine;
 }
 
@@ -27410,7 +27506,14 @@ thumb2_expand_return (bool simple_return)
 	 to assert it for now to ensure that future code changes do not silently
 	 change this behavior.  */
       gcc_assert (!IS_CMSE_ENTRY (arm_current_func_type ()));
-      if (num_regs == 1)
+      if (arm_current_function_pac_enabled_p ())
+        {
+          gcc_assert (!(saved_regs_mask & (1 << PC_REGNUM)));
+          arm_emit_multi_reg_pop (saved_regs_mask);
+          emit_insn (gen_aut_nop ());
+          emit_jump_insn (simple_return_rtx);
+        }
+      else if (num_regs == 1)
         {
           rtx par = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (2));
           rtx reg = gen_rtx_REG (SImode, PC_REGNUM);
@@ -27834,7 +27937,8 @@ arm_expand_epilogue (bool really_return)
           && really_return
           && crtl->args.pretend_args_size == 0
           && saved_regs_mask & (1 << LR_REGNUM)
-          && !crtl->calls_eh_return)
+          && !crtl->calls_eh_return
+	  && !arm_current_function_pac_enabled_p ())
         {
           saved_regs_mask &= ~(1 << LR_REGNUM);
           saved_regs_mask |= (1 << PC_REGNUM);
@@ -27948,6 +28052,9 @@ arm_expand_epilogue (bool really_return)
 	}
     }
 
+  if (arm_current_function_pac_enabled_p ())
+    emit_insn (gen_aut_nop ());
+
   if (!really_return)
     return;
 
@@ -28460,6 +28567,8 @@ static void
 arm_file_start (void)
 {
   int val;
+  bool pac = (aarch_ra_sign_scope != AARCH_FUNCTION_NONE);
+  bool bti = (aarch_enable_bti == 1);
 
   arm_print_asm_arch_directives
     (asm_out_file, TREE_TARGET_OPTION (target_option_default_node));
@@ -28530,6 +28639,22 @@ arm_file_start (void)
 	arm_emit_eabi_attribute ("Tag_ABI_FP_16bit_format", 38,
 			     (int) arm_fp16_format);
 
+      if (TARGET_HAVE_PACBTI)
+	{
+	  arm_emit_eabi_attribute ("Tag_PAC_extension", 50, 2);
+	  arm_emit_eabi_attribute ("Tag_BTI_extension", 52, 2);
+	}
+      else if (pac || bti)
+	{
+	  arm_emit_eabi_attribute ("Tag_PAC_extension", 50, 1);
+	  arm_emit_eabi_attribute ("Tag_BTI_extension", 52, 1);
+	}
+
+      if (bti)
+        arm_emit_eabi_attribute ("TAG_BTI_use", 74, 1);
+      if (pac)
+	arm_emit_eabi_attribute ("TAG_PACRET_use", 76, 1);
+
       if (arm_lang_output_object_attributes_hook)
 	arm_lang_output_object_attributes_hook();
     }
@@ -29618,6 +29743,9 @@ arm_debugger_regno (unsigned int regno)
   if (IS_IWMMXT_REGNUM (regno))
     return 112 + regno - FIRST_IWMMXT_REGNUM;
 
+  if (IS_PAC_REGNUM (regno))
+    return DWARF_PAC_REGNUM;
+
   return DWARF_FRAME_REGISTERS;
 }
 
@@ -29711,7 +29839,7 @@ arm_unwind_emit_sequence (FILE * out_file, rtx p)
   gcc_assert (nregs);
 
   reg = REGNO (SET_SRC (XVECEXP (p, 0, 1)));
-  if (reg < 16)
+  if (reg < 16 || IS_PAC_REGNUM (reg))
     {
       /* For -Os dummy registers can be pushed at the beginning to
 	 avoid separate stack pointer adjustment.  */
@@ -29768,6 +29896,8 @@ arm_unwind_emit_sequence (FILE * out_file, rtx p)
 	 double precision register names.  */
       if (IS_VFP_REGNUM (reg))
 	asm_fprintf (out_file, "d%d", (reg - FIRST_VFP_REGNUM) / 2);
+      else if (IS_PAC_REGNUM (reg))
+	asm_fprintf (asm_out_file, "ra_auth_code");
       else
 	asm_fprintf (out_file, "%r", reg);
 
@@ -29862,7 +29992,7 @@ arm_unwind_emit_set (FILE * out_file, rtx p)
 	  /* Move from sp to reg.  */
 	  asm_fprintf (out_file, "\t.movsp %r\n", REGNO (e0));
 	}
-     else if (GET_CODE (e1) == PLUS
+      else if (GET_CODE (e1) == PLUS
 	      && REG_P (XEXP (e1, 0))
 	      && REGNO (XEXP (e1, 0)) == SP_REGNUM
 	      && CONST_INT_P (XEXP (e1, 1)))
@@ -29871,6 +30001,11 @@ arm_unwind_emit_set (FILE * out_file, rtx p)
 	  asm_fprintf (out_file, "\t.movsp %r, #%d\n",
 		       REGNO (e0), (int)INTVAL(XEXP (e1, 1)));
 	}
+      else if (REGNO (e0) == IP_REGNUM && arm_current_function_pac_enabled_p ())
+	{
+	  if (cfun->machine->pacspval_needed)
+	    asm_fprintf (out_file, "\t.pacspval\n");
+	}
       else
 	abort ();
       break;
@@ -29925,10 +30060,15 @@ arm_unwind_emit (FILE * out_file, rtx_insn *insn)
 	    src = SET_SRC (pat);
 	    dest = SET_DEST (pat);
 
-	    gcc_assert (src == stack_pointer_rtx);
+	    gcc_assert (src == stack_pointer_rtx
+			|| IS_PAC_REGNUM (REGNO (src)));
 	    reg = REGNO (dest);
-	    asm_fprintf (out_file, "\t.unwind_raw 0, 0x%x @ vsp = r%d\n",
-			 reg + 0x90, reg);
+
+	    if (IS_PAC_REGNUM (REGNO (src)))
+	      arm_unwind_emit_set (out_file, PATTERN (insn));
+	    else
+	      asm_fprintf (out_file, "\t.unwind_raw 0, 0x%x @ vsp = r%d\n",
+			   reg + 0x90, reg);
 	  }
 	  handled_one = true;
 	  break;
@@ -33031,6 +33171,78 @@ arm_fusion_enabled_p (tune_params::fuse_ops op)
   return current_tune->fusible_ops & op;
 }
 
+/* Return TRUE if return address signing mechanism is enabled.  */
+bool
+arm_current_function_pac_enabled_p (void)
+{
+  return (aarch_ra_sign_scope == AARCH_FUNCTION_ALL
+          || (aarch_ra_sign_scope == AARCH_FUNCTION_NON_LEAF
+              && !crtl->is_leaf));
+}
+
+/* Raise an error if the current target arch is not bti compatible.  */
+void aarch_bti_arch_check (void)
+{
+  if (!arm_arch8m_main)
+    error ("This architecture does not support branch protection instructions");
+}
+
+/* Return TRUE if Branch Target Identification Mechanism is enabled.  */
+bool
+aarch_bti_enabled (void)
+{
+  return aarch_enable_bti != 0;
+}
+
+/* Check if INSN is a BTI J insn.  */
+bool
+aarch_bti_j_insn_p (rtx_insn *insn)
+{
+  if (!insn || !INSN_P (insn))
+    return false;
+
+  rtx pat = PATTERN (insn);
+  return GET_CODE (pat) == UNSPEC_VOLATILE && XINT (pat, 1) == VUNSPEC_BTI_NOP;
+}
+
+/* Check if X (or any sub-rtx of X) is a PACIASP/PACIBSP instruction.  */
+bool
+aarch_pac_insn_p (rtx x)
+{
+  if (!x || !INSN_P (x))
+    return false;
+
+  rtx pat = PATTERN (x);
+
+  if (GET_CODE (pat) == SET)
+    {
+      rtx tmp = XEXP (pat, 1);
+      if (tmp
+	  && ((GET_CODE (tmp) == UNSPEC
+               && XINT (tmp, 1) == UNSPEC_PAC_NOP)
+              || (GET_CODE (tmp) == UNSPEC_VOLATILE
+                  && XINT (tmp, 1) == VUNSPEC_PACBTI_NOP)))
+	return true;
+    }
+
+  return false;
+}
+
+ /* Target specific mapping for aarch_gen_bti_c and aarch_gen_bti_j.
+    For Arm, both of these map to a simple BTI instruction.  */
+
+rtx
+aarch_gen_bti_c (void)
+{
+  return gen_bti_nop ();
+}
+
+rtx
+aarch_gen_bti_j (void)
+{
+  return gen_bti_nop ();
+}
+
 /* Implement TARGET_SCHED_CAN_SPECULATE_INSN.  Return true if INSN can be
    scheduled for speculative execution.  Reject the long-running division
    and square-root instructions.  */
diff --git a/gcc/config/arm/arm.h b/gcc/config/arm/arm.h
index 6f7ecf9..6327283 100644
--- a/gcc/config/arm/arm.h
+++ b/gcc/config/arm/arm.h
@@ -331,6 +331,12 @@ emission of floating point pcs attributes.  */
 						isa_bit_mve_float) \
 			       && !TARGET_GENERAL_REGS_ONLY)
 
+/* Non-zero if this target supports Armv8.1-M Mainline pointer-signing
+   extension.  */
+#define TARGET_HAVE_PACBTI (arm_arch8_1m_main \
+			    && bitmap_bit_p (arm_active_target.isa, \
+					     isa_bit_pacbti))
+
 /* MVE have few common instructions as VFP, like VLDM alias VPOP, VLDR, VSTM
    alia VPUSH, VSTR and VMOV, VMSR and VMRS.  In the same manner it updates few
    registers such as FPCAR, FPCCR, FPDSCR, FPSCR, MVFR0, MVFR1 and MVFR2.  All
@@ -500,6 +506,10 @@ extern int arm_arch8_3;
 /* Nonzero if this chip supports the ARM Architecture 8.4 extensions.  */
 extern int arm_arch8_4;
 
+/* Nonzero if this chip supports the ARM Architecture 8-M Mainline
+   extensions.  */
+extern int arm_arch8m_main;
+
 /* Nonzero if this chip supports the ARM Architecture 8.1-M Mainline
    extensions.  */
 extern int arm_arch8_1m_main;
@@ -806,7 +816,8 @@ extern const int arm_arch_cde_coproc_bits[];
 	s16-s31	      S	VFP variable (aka d8-d15).
 	vfpcc		Not a real register.  Represents the VFP condition
 			code flags.
-	vpr		Used to represent MVE VPR predication.  */
+	vpr		Used to represent MVE VPR predication.
+	ra_auth_code	Pseudo register to save PAC.  */
 
 /* The stack backtrace structure is as follows:
   fp points to here:  |  save code pointer  |      [fp]
@@ -847,7 +858,7 @@ extern const int arm_arch_cde_coproc_bits[];
   1,1,1,1,1,1,1,1,		\
   1,1,1,1,			\
   /* Specials.  */		\
-  1,1,1,1,1,1,1			\
+  1,1,1,1,1,1,1,1		\
 }
 
 /* 1 for registers not available across function calls.
@@ -877,7 +888,7 @@ extern const int arm_arch_cde_coproc_bits[];
   1,1,1,1,1,1,1,1,		\
   1,1,1,1,			\
   /* Specials.  */		\
-  1,1,1,1,1,1,1			\
+  1,1,1,1,1,1,1,1		\
 }
 
 #ifndef SUBTARGET_CONDITIONAL_REGISTER_USAGE
@@ -1053,10 +1064,12 @@ extern const int arm_arch_cde_coproc_bits[];
    && (LAST_VFP_REGNUM - (REGNUM) >= 2 * (N) - 1))
 
 /* The number of hard registers is 16 ARM + 1 CC + 1 SFP + 1 AFP
-   + 1 APSRQ + 1 APSRGE + 1 VPR.  */
+   + 1 APSRQ + 1 APSRGE + 1 VPR + 1 Pseudo register to save PAC.  */
 /* Intel Wireless MMX Technology registers add 16 + 4 more.  */
 /* VFP (VFP3) adds 32 (64) + 1 VFPCC.  */
-#define FIRST_PSEUDO_REGISTER   107
+#define FIRST_PSEUDO_REGISTER   108
+
+#define DWARF_PAC_REGNUM 143
 
 #define DEBUGGER_REGNO(REGNO) arm_debugger_regno (REGNO)
 
@@ -1243,12 +1256,15 @@ extern int arm_regs_in_sequence[];
   CC_REGNUM, VFPCC_REGNUM,			\
   FRAME_POINTER_REGNUM, ARG_POINTER_REGNUM,	\
   SP_REGNUM, PC_REGNUM, APSRQ_REGNUM,		\
-  APSRGE_REGNUM, VPR_REGNUM			\
+  APSRGE_REGNUM, VPR_REGNUM, RA_AUTH_CODE	\
 }
 
 #define IS_VPR_REGNUM(REGNUM) \
   ((REGNUM) == VPR_REGNUM)
 
+#define IS_PAC_REGNUM(REGNUM) \
+  ((REGNUM) == RA_AUTH_CODE)
+
 /* Use different register alloc ordering for Thumb.  */
 #define ADJUST_REG_ALLOC_ORDER arm_order_regs_for_local_alloc ()
 
@@ -1287,6 +1303,7 @@ enum reg_class
   SFP_REG,
   AFP_REG,
   VPR_REG,
+  PAC_REG,
   GENERAL_AND_VPR_REGS,
   ALL_REGS,
   LIM_REG_CLASSES
@@ -1317,6 +1334,7 @@ enum reg_class
   "SFP_REG",		\
   "AFP_REG",		\
   "VPR_REG",		\
+  "PAC_REG",		\
   "GENERAL_AND_VPR_REGS", \
   "ALL_REGS"		\
 }
@@ -1346,6 +1364,7 @@ enum reg_class
   { 0x00000000, 0x00000000, 0x00000000, 0x00000040 }, /* SFP_REG */	\
   { 0x00000000, 0x00000000, 0x00000000, 0x00000080 }, /* AFP_REG */	\
   { 0x00000000, 0x00000000, 0x00000000, 0x00000400 }, /* VPR_REG.  */	\
+  { 0x00000000, 0x00000000, 0x00000000, 0x00000800 }, /* PAC_REG.  */	\
   { 0x00005FFF, 0x00000000, 0x00000000, 0x00000400 }, /* GENERAL_AND_VPR_REGS.  */ \
   { 0xFFFF7FFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x0000040F }  /* ALL_REGS.  */	\
 }
@@ -1611,6 +1630,9 @@ typedef struct GTY(()) machine_function
   /* The number of bytes used to store the static chain register on the
      stack, above the stack frame.  */
   int static_chain_stack_bytes;
+  /* Set to 1 when pointer authentication operation uses value of SP other
+     than the incoming stack pointer value.  */
+  int pacspval_needed;
 }
 machine_function;
 #endif
diff --git a/gcc/config/arm/arm.md b/gcc/config/arm/arm.md
index 3710c5c..cbfc454 100644
--- a/gcc/config/arm/arm.md
+++ b/gcc/config/arm/arm.md
@@ -42,6 +42,7 @@
    (APSRQ_REGNUM    104)	; Q bit pseudo register
    (APSRGE_REGNUM   105)	; GE bits pseudo register
    (VPR_REGNUM      106)	; Vector Predication Register - MVE register.
+   (RA_AUTH_CODE    107)	; Pseudo register to save PAC.
   ]
 )
 ;; 3rd operand to select_dominance_cc_mode
@@ -12986,6 +12987,36 @@
    (set_attr "length" "8")]
 )
 
+(define_insn "pac_nop"
+  [(set (reg:SI IP_REGNUM)
+	(unspec:SI [(reg:SI SP_REGNUM) (reg:SI LR_REGNUM)]
+		   UNSPEC_PAC_NOP))]
+  "arm_arch8m_main"
+  "pac\t%|ip, %|lr, %|sp"
+  [(set_attr "conds" "unconditional")])
+
+(define_insn "pacbti_nop"
+  [(set (reg:SI IP_REGNUM)
+	(unspec_volatile:SI [(reg:SI SP_REGNUM) (reg:SI LR_REGNUM)]
+			    VUNSPEC_PACBTI_NOP))]
+  "arm_arch8m_main"
+  "pacbti\t%|ip, %|lr, %|sp"
+  [(set_attr "conds" "unconditional")])
+
+(define_insn "aut_nop"
+  [(unspec_volatile:SI [(reg:SI IP_REGNUM) (reg:SI SP_REGNUM) (reg:SI LR_REGNUM)]
+		       VUNSPEC_AUT_NOP)]
+  "arm_arch8m_main"
+  "aut\t%|ip, %|lr, %|sp"
+  [(set_attr "conds" "unconditional")])
+
+(define_insn "bti_nop"
+  [(unspec_volatile [(const_int 0)] VUNSPEC_BTI_NOP)]
+  "arm_arch8m_main"
+  "bti"
+  [(set_attr "conds" "unconditional")
+   (set_attr "type" "nop")])
+
 ;; Vector bits common to IWMMXT, Neon and MVE
 (include "vec-common.md")
 ;; Load the Intel Wireless Multimedia Extension patterns
diff --git a/gcc/config/arm/arm.opt b/gcc/config/arm/arm.opt
index 007d993..260700f 100644
--- a/gcc/config/arm/arm.opt
+++ b/gcc/config/arm/arm.opt
@@ -21,6 +21,15 @@
 HeaderInclude
 config/arm/arm-opts.h
 
+HeaderInclude
+config/arm/aarch-common.h
+
+TargetVariable
+enum aarch_function_type aarch_ra_sign_scope = AARCH_FUNCTION_NONE
+
+TargetVariable
+unsigned aarch_enable_bti = 0
+
 Enum
 Name(tls_type) Type(enum arm_tls_type)
 TLS dialect to use:
@@ -314,6 +323,10 @@ mbranch-cost=
 Target RejectNegative Joined UInteger Var(arm_branch_cost) Init(-1)
 Cost to assume for a branch insn.
 
+mbranch-protection=
+Target RejectNegative Joined Var(arm_branch_protection_string) Save
+Use branch-protection features.
+
 mgeneral-regs-only
 Target RejectNegative Mask(GENERAL_REGS_ONLY) Save
 Generate code which uses the core registers only (r0-r14).
diff --git a/gcc/config/arm/arm_mve.h b/gcc/config/arm/arm_mve.h
index 00fb42a..bfbe1cd 100644
--- a/gcc/config/arm/arm_mve.h
+++ b/gcc/config/arm/arm_mve.h
@@ -16171,14 +16171,14 @@ __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 __arm_vst1q_p_u8 (uint8_t * __addr, uint8x16_t __value, mve_pred16_t __p)
 {
-  return vstrbq_p_u8 (__addr, __value, __p);
+  return __arm_vstrbq_p_u8 (__addr, __value, __p);
 }
 
 __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 __arm_vst1q_p_s8 (int8_t * __addr, int8x16_t __value, mve_pred16_t __p)
 {
-  return vstrbq_p_s8 (__addr, __value, __p);
+  return __arm_vstrbq_p_s8 (__addr, __value, __p);
 }
 
 __extension__ extern __inline void
@@ -16203,14 +16203,14 @@ __extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 __arm_vld1q_z_u8 (uint8_t const *__base, mve_pred16_t __p)
 {
-  return vldrbq_z_u8 ( __base, __p);
+  return __arm_vldrbq_z_u8 ( __base, __p);
 }
 
 __extension__ extern __inline int8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 __arm_vld1q_z_s8 (int8_t const *__base, mve_pred16_t __p)
 {
-  return vldrbq_z_s8 ( __base, __p);
+  return __arm_vldrbq_z_s8 ( __base, __p);
 }
 
 __extension__ extern __inline int8x16x2_t
@@ -16253,14 +16253,14 @@ __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 __arm_vst1q_p_u16 (uint16_t * __addr, uint16x8_t __value, mve_pred16_t __p)
 {
-  return vstrhq_p_u16 (__addr, __value, __p);
+  return __arm_vstrhq_p_u16 (__addr, __value, __p);
 }
 
 __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 __arm_vst1q_p_s16 (int16_t * __addr, int16x8_t __value, mve_pred16_t __p)
 {
-  return vstrhq_p_s16 (__addr, __value, __p);
+  return __arm_vstrhq_p_s16 (__addr, __value, __p);
 }
 
 __extension__ extern __inline void
@@ -16285,14 +16285,14 @@ __extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 __arm_vld1q_z_u16 (uint16_t const *__base, mve_pred16_t __p)
 {
-  return vldrhq_z_u16 ( __base, __p);
+  return __arm_vldrhq_z_u16 ( __base, __p);
 }
 
 __extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 __arm_vld1q_z_s16 (int16_t const *__base, mve_pred16_t __p)
 {
-  return vldrhq_z_s16 ( __base, __p);
+  return __arm_vldrhq_z_s16 ( __base, __p);
 }
 
 __extension__ extern __inline int16x8x2_t
@@ -16335,14 +16335,14 @@ __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 __arm_vst1q_p_u32 (uint32_t * __addr, uint32x4_t __value, mve_pred16_t __p)
 {
-  return vstrwq_p_u32 (__addr, __value, __p);
+  return __arm_vstrwq_p_u32 (__addr, __value, __p);
 }
 
 __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 __arm_vst1q_p_s32 (int32_t * __addr, int32x4_t __value, mve_pred16_t __p)
 {
-  return vstrwq_p_s32 (__addr, __value, __p);
+  return __arm_vstrwq_p_s32 (__addr, __value, __p);
 }
 
 __extension__ extern __inline void
@@ -16367,14 +16367,14 @@ __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 __arm_vld1q_z_u32 (uint32_t const *__base, mve_pred16_t __p)
 {
-  return vldrwq_z_u32 ( __base, __p);
+  return __arm_vldrwq_z_u32 ( __base, __p);
 }
 
 __extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 __arm_vld1q_z_s32 (int32_t const *__base, mve_pred16_t __p)
 {
-  return vldrwq_z_s32 ( __base, __p);
+  return __arm_vldrwq_z_s32 ( __base, __p);
 }
 
 __extension__ extern __inline int32x4x2_t
@@ -19837,7 +19837,7 @@ __extension__ extern __inline float16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 __arm_vld1q_z_f16 (float16_t const *__base, mve_pred16_t __p)
 {
-  return vldrhq_z_f16 (__base, __p);
+  return __arm_vldrhq_z_f16 (__base, __p);
 }
 
 __extension__ extern __inline void
@@ -19853,7 +19853,7 @@ __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 __arm_vst1q_p_f16 (float16_t * __addr, float16x8_t __value, mve_pred16_t __p)
 {
-  return vstrhq_p_f16 (__addr, __value, __p);
+  return __arm_vstrhq_p_f16 (__addr, __value, __p);
 }
 
 __extension__ extern __inline float32x4x4_t
@@ -19878,7 +19878,7 @@ __extension__ extern __inline float32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 __arm_vld1q_z_f32 (float32_t const *__base, mve_pred16_t __p)
 {
-  return vldrwq_z_f32 (__base, __p);
+  return __arm_vldrwq_z_f32 (__base, __p);
 }
 
 __extension__ extern __inline void
@@ -19894,7 +19894,7 @@ __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 __arm_vst1q_p_f32 (float32_t * __addr, float32x4_t __value, mve_pred16_t __p)
 {
-  return vstrwq_p_f32 (__addr, __value, __p);
+  return __arm_vstrwq_p_f32 (__addr, __value, __p);
 }
 
 __extension__ extern __inline float16x8_t
@@ -35659,9 +35659,9 @@ extern void *__ARM_undef;
 #define __ARM_mve_coerce1(param, type) \
     _Generic(param, type: param, const type: param, default: *(type *)__ARM_undef)
 #define __ARM_mve_coerce2(param, type) \
-    _Generic(param, type: param, float16_t: param, float32_t: param, default: *(type *)__ARM_undef)
+    _Generic(param, type: param, __fp16: param, default: _Generic (param, _Float16: param, float16_t: param, float32_t: param, default: *(type *)__ARM_undef))
 #define __ARM_mve_coerce3(param, type) \
-    _Generic(param, type: param, int8_t: param, int16_t: param, int32_t: param, int64_t: param, uint8_t: param, uint16_t: param, uint32_t: param, uint64_t: param, default: *(type *)__ARM_undef)
+    _Generic(param, type: param, default: _Generic (param, int8_t: param, int16_t: param, int32_t: param, int64_t: param, uint8_t: param, uint16_t: param, uint32_t: param, uint64_t: param, default: *(type *)__ARM_undef))
 
 #if (__ARM_FEATURE_MVE & 2) /* MVE Floating point.  */
 
diff --git a/gcc/config/arm/mve.md b/gcc/config/arm/mve.md
index f123edc..555ad1b 100644
--- a/gcc/config/arm/mve.md
+++ b/gcc/config/arm/mve.md
@@ -252,7 +252,7 @@
 	(neg:MVE_0 (match_operand:MVE_0 1 "s_register_operand" "w")))
   ]
   "TARGET_HAVE_MVE && TARGET_HAVE_MVE_FLOAT"
-  "vneg.f%#<V_sz_elem>  %q0, %q1"
+  "vneg.f%#<V_sz_elem>\t%q0, %q1"
   [(set_attr "type" "mve_move")
 ])
 
@@ -374,7 +374,7 @@
 	 VQNEGQ_S))
   ]
   "TARGET_HAVE_MVE"
-  "vqneg.s%#<V_sz_elem> %q0, %q1"
+  "vqneg.s%#<V_sz_elem>\t%q0, %q1"
   [(set_attr "type" "mve_move")
 ])
 
@@ -388,7 +388,7 @@
 	 VQABSQ_S))
   ]
   "TARGET_HAVE_MVE"
-  "vqabs.s%#<V_sz_elem> %q0, %q1"
+  "vqabs.s%#<V_sz_elem>\t%q0, %q1"
   [(set_attr "type" "mve_move")
 ])
 
@@ -401,7 +401,7 @@
 	(neg:MVE_2 (match_operand:MVE_2 1 "s_register_operand" "w")))
   ]
   "TARGET_HAVE_MVE"
-  "vneg.s%#<V_sz_elem>  %q0, %q1"
+  "vneg.s%#<V_sz_elem>\t%q0, %q1"
   [(set_attr "type" "mve_move")
 ])
 
@@ -448,7 +448,7 @@
 	(clz:MVE_2 (match_operand:MVE_2 1 "s_register_operand" "w")))
   ]
   "TARGET_HAVE_MVE"
-  "vclz.i%#<V_sz_elem>  %q0, %q1"
+  "vclz.i%#<V_sz_elem>\t%q0, %q1"
   [(set_attr "type" "mve_move")
 ])
 (define_expand "mve_vclzq_u<mode>"
@@ -469,7 +469,7 @@
 	 VCLSQ_S))
   ]
   "TARGET_HAVE_MVE"
-  "vcls.s%#<V_sz_elem>  %q0, %q1"
+  "vcls.s%#<V_sz_elem>\t%q0, %q1"
   [(set_attr "type" "mve_move")
 ])
 
@@ -7272,15 +7272,13 @@
 }
   [(set_attr "length" "8")])
 
-;;
-;; [vstrbq_p_s vstrbq_p_u]
-;;
 (define_insn "mve_vstrbq_p_<supf><mode>"
   [(set (match_operand:<MVE_B_ELEM> 0 "mve_memory_operand" "=Ux")
-	(unspec:<MVE_B_ELEM> [(match_operand:MVE_2 1 "s_register_operand" "w")
-			      (match_operand:<MVE_VPRED> 2 "vpr_register_operand" "Up")]
-	 VSTRBQ))
-  ]
+	(unspec:<MVE_B_ELEM>
+	 [(match_operand:MVE_2 1 "s_register_operand" "w")
+	  (match_operand:<MVE_VPRED> 2 "vpr_register_operand" "Up")
+	  (match_dup 0)]
+	 VSTRBQ))]
   "TARGET_HAVE_MVE"
 {
    rtx ops[2];
@@ -8079,10 +8077,11 @@
 ;;
 (define_insn "mve_vstrhq_p_fv8hf"
   [(set (match_operand:V8HI 0 "mve_memory_operand" "=Ux")
-	(unspec:V8HI [(match_operand:V8HF 1 "s_register_operand" "w")
-		      (match_operand:V8BI 2 "vpr_register_operand" "Up")]
-	 VSTRHQ_F))
-  ]
+	(unspec:V8HI
+	 [(match_operand:V8HF 1 "s_register_operand" "w")
+	  (match_operand:V8BI 2 "vpr_register_operand" "Up")
+	  (match_dup 0)]
+	 VSTRHQ_F))]
   "TARGET_HAVE_MVE && TARGET_HAVE_MVE_FLOAT"
 {
    rtx ops[2];
@@ -8099,8 +8098,10 @@
 ;;
 (define_insn "mve_vstrhq_p_<supf><mode>"
   [(set (match_operand:<MVE_H_ELEM> 0 "mve_memory_operand" "=Ux")
-	(unspec:<MVE_H_ELEM> [(match_operand:MVE_6 1 "s_register_operand" "w")
-			      (match_operand:<MVE_VPRED> 2 "vpr_register_operand" "Up")]
+	(unspec:<MVE_H_ELEM>
+	 [(match_operand:MVE_6 1 "s_register_operand" "w")
+	  (match_operand:<MVE_VPRED> 2 "vpr_register_operand" "Up")
+	  (match_dup 0)]
 	 VSTRHQ))
   ]
   "TARGET_HAVE_MVE"
@@ -8278,10 +8279,11 @@
 ;;
 (define_insn "mve_vstrwq_p_fv4sf"
   [(set (match_operand:V4SI 0 "mve_memory_operand" "=Ux")
-	(unspec:V4SI [(match_operand:V4SF 1 "s_register_operand" "w")
-		      (match_operand:<MVE_VPRED> 2 "vpr_register_operand" "Up")]
-	 VSTRWQ_F))
-  ]
+	(unspec:V4SI
+	 [(match_operand:V4SF 1 "s_register_operand" "w")
+	  (match_operand:<MVE_VPRED> 2 "vpr_register_operand" "Up")
+	  (match_dup 0)]
+	 VSTRWQ_F))]
   "TARGET_HAVE_MVE && TARGET_HAVE_MVE_FLOAT"
 {
    rtx ops[2];
@@ -8298,10 +8300,11 @@
 ;;
 (define_insn "mve_vstrwq_p_<supf>v4si"
   [(set (match_operand:V4SI 0 "mve_memory_operand" "=Ux")
-	(unspec:V4SI [(match_operand:V4SI 1 "s_register_operand" "w")
-		      (match_operand:V4BI 2 "vpr_register_operand" "Up")]
-	 VSTRWQ))
-  ]
+	(unspec:V4SI
+	 [(match_operand:V4SI 1 "s_register_operand" "w")
+	  (match_operand:V4BI 2 "vpr_register_operand" "Up")
+	  (match_dup 0)]
+	 VSTRWQ))]
   "TARGET_HAVE_MVE"
 {
    rtx ops[2];
diff --git a/gcc/config/arm/t-arm b/gcc/config/arm/t-arm
index b4d5d94..637e72a 100644
--- a/gcc/config/arm/t-arm
+++ b/gcc/config/arm/t-arm
@@ -175,3 +175,13 @@ arm-d.o: $(srcdir)/config/arm/arm-d.cc
 arm-common.o: arm-cpu-cdata.h
 
 driver-arm.o: arm-native.h
+
+PASSES_EXTRA += $(srcdir)/config/arm/arm-passes.def
+
+aarch-bti-insert.o: $(srcdir)/config/arm/aarch-bti-insert.cc \
+    $(CONFIG_H) $(SYSTEM_H) $(TM_H) $(REGS_H) insn-config.h $(RTL_BASE_H) \
+    dominance.h cfg.h cfganal.h $(BASIC_BLOCK_H) $(INSN_ATTR_H) $(RECOG_H) \
+    output.h hash-map.h $(DF_H) $(OBSTACK_H) $(TARGET_H) $(RTL_H) \
+    $(CONTEXT_H) $(TREE_PASS_H) regrename.h
+	$(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \
+		$(srcdir)/config/arm/aarch-bti-insert.cc
diff --git a/gcc/config/arm/t-rmprofile b/gcc/config/arm/t-rmprofile
index 472ed94..4d8e6ce 100644
--- a/gcc/config/arm/t-rmprofile
+++ b/gcc/config/arm/t-rmprofile
@@ -27,8 +27,11 @@
 
 # Arch and FPU variants to build libraries with
 
-MULTI_ARCH_OPTS_RM	= march=armv6s-m/march=armv7-m/march=armv7e-m/march=armv7e-m+fp/march=armv7e-m+fp.dp/march=armv8-m.base/march=armv8-m.main/march=armv8-m.main+fp/march=armv8-m.main+fp.dp/march=armv8.1-m.main+mve
-MULTI_ARCH_DIRS_RM	= v6-m v7-m v7e-m v7e-m+fp v7e-m+dp v8-m.base v8-m.main v8-m.main+fp v8-m.main+dp v8.1-m.main+mve
+MULTI_ARCH_OPTS_RM	= march=armv6s-m/march=armv7-m/march=armv7e-m/march=armv7e-m+fp/march=armv7e-m+fp.dp/march=armv8-m.base/march=armv8-m.main/march=armv8-m.main+fp/march=armv8-m.main+fp.dp/march=armv8.1-m.main+mve/march=armv8.1-m.main+pacbti/march=armv8.1-m.main+pacbti+fp/march=armv8.1-m.main+pacbti+fp.dp/march=armv8.1-m.main+pacbti+mve
+MULTI_ARCH_DIRS_RM	= v6-m v7-m v7e-m v7e-m+fp v7e-m+dp v8-m.base v8-m.main v8-m.main+fp v8-m.main+dp v8.1-m.main+mve v8.1-m.main+pacbti v8.1-m.main+pacbti+fp v8.1-m.main+pacbti+dp v8.1-m.main+pacbti+mve
+
+MULTI_ARCH_OPTS_RM	+= mbranch-protection=standard
+MULTI_ARCH_DIRS_RM	+= bp
 
 # Base M-profile (no fp)
 MULTILIB_REQUIRED	+= mthumb/march=armv6s-m/mfloat-abi=soft
@@ -50,6 +53,13 @@ MULTILIB_REQUIRED	+= mthumb/march=armv8-m.main+fp.dp/mfloat-abi=hard
 MULTILIB_REQUIRED	+= mthumb/march=armv8-m.main+fp.dp/mfloat-abi=softfp
 MULTILIB_REQUIRED	+= mthumb/march=armv8.1-m.main+mve/mfloat-abi=hard
 
+MULTILIB_REQUIRED	+= mthumb/march=armv8.1-m.main+pacbti/mbranch-protection=standard/mfloat-abi=soft
+MULTILIB_REQUIRED	+= mthumb/march=armv8.1-m.main+pacbti+fp/mbranch-protection=standard/mfloat-abi=softfp
+MULTILIB_REQUIRED	+= mthumb/march=armv8.1-m.main+pacbti+fp/mbranch-protection=standard/mfloat-abi=hard
+MULTILIB_REQUIRED	+= mthumb/march=armv8.1-m.main+pacbti+fp.dp/mbranch-protection=standard/mfloat-abi=softfp
+MULTILIB_REQUIRED	+= mthumb/march=armv8.1-m.main+pacbti+fp.dp/mbranch-protection=standard/mfloat-abi=hard
+MULTILIB_REQUIRED	+= mthumb/march=armv8.1-m.main+pacbti+mve/mbranch-protection=standard/mfloat-abi=hard
+
 # Arch Matches
 MULTILIB_MATCHES	+= march?armv6s-m=march?armv6-m
 
@@ -87,9 +97,63 @@ MULTILIB_MATCHES += $(foreach FP, $(v8_1m_sp_variants), \
 MULTILIB_MATCHES += $(foreach FP, $(v8_1m_dp_variants), \
 			     march?armv8-m.main+fp.dp=mlibarch?armv8.1-m.main$(FP))
 
+# Map all mbranch-protection values other than 'none' to 'standard'.
+MULTILIB_MATCHES	+= mbranch-protection?standard=mbranch-protection?bti
+MULTILIB_MATCHES	+= mbranch-protection?standard=mbranch-protection?pac-ret
+MULTILIB_MATCHES	+= mbranch-protection?standard=mbranch-protection?pac-ret+leaf
+MULTILIB_MATCHES	+= mbranch-protection?standard=mbranch-protection?pac-ret+bti
+MULTILIB_MATCHES	+= mbranch-protection?standard=mbranch-protection?pac-ret+leaf+bti
+MULTILIB_MATCHES	+= mbranch-protection?standard=mbranch-protection?bti+pac-ret
+MULTILIB_MATCHES	+= mbranch-protection?standard=mbranch-protection?bti+pac-ret+leaf
+MULTILIB_MATCHES	+= mbranch-protection?standard=mbranch-protection?standard+leaf
+
 # For all the MULTILIB_REQUIRED for v8-m and above, add MULTILIB_MATCHES which
 # maps mlibarch with march for multilib linking.
 MULTILIB_MATCHES	+= march?armv8-m.main=mlibarch?armv8-m.main
 MULTILIB_MATCHES	+= march?armv8-m.main+fp=mlibarch?armv8-m.main+fp
 MULTILIB_MATCHES	+= march?armv8-m.main+fp.dp=mlibarch?armv8-m.main+fp.dp
 MULTILIB_MATCHES	+= march?armv8.1-m.main+mve=mlibarch?armv8.1-m.main+mve
+
+# For -mbranch-protection=none and +pacbti reuses the existing non pacbti
+# multilibs.
+MULTILIB_REUSE		+= $(foreach OPT, fp fp\.dp, \
+			     mthumb/march.armv8-m\.main+$(OPT)/mfloat-abi.softfp=mthumb/march.armv8\.1-m\.main+pacbti+$(OPT)/mfloat-abi.softfp)
+MULTILIB_REUSE		+= $(foreach OPT, fp fp\.dp, \
+			     mthumb/march.armv8-m\.main+$(OPT)/mfloat-abi.hard=mthumb/march.armv8\.1-m\.main+pacbti+$(OPT)/mfloat-abi.hard)
+
+MULTILIB_REUSE		+= $(foreach OPT, pacbti pacbti+mve, \
+			     mthumb/march.armv8-m\.main/mfloat-abi.soft=mthumb/march.armv8\.1-m\.main+$(OPT)/mfloat-abi.soft)
+MULTILIB_REUSE		+= $(foreach OPT, pacbti pacbti+mve, \
+			     mthumb/march.armv8-m\.main/mfloat-abi.soft=mthumb/march.armv8\.1-m\.main+$(OPT)/mfloat-abi.softfp)
+
+MULTILIB_REUSE		+= mthumb/march.armv8\.1-m\.main+mve/mfloat-abi.hard=mthumb/march.armv8\.1-m\.main+pacbti+mve/mfloat-abi.hard
+
+pacbti_fp_variants =  fp fp+mve mve.fp fp+mve.fp
+pacbti_dp_variants = fp.dp fp.dp+mve fp.dp+mve.fp
+
+# For -mbranch-protection=standard and +pacbti linking to existing pacbti
+# multlibs.
+MULTILIB_MATCHES	+= march?armv8.1-m.main+pacbti=mlibarch?armv8.1-m.main+pacbti
+MULTILIB_MATCHES	+= march?armv8.1-m.main+pacbti=mlibarch?armv8.1-m.main+pacbti+dsp
+MULTILIB_MATCHES	+= march?armv8.1-m.main+pacbti=mlibarch?armv8.1-m.main+dsp+pacbti
+MULTILIB_MATCHES	+= march?armv8.1-m.main+pacbti+mve=mlibarch?armv8.1-m.main+pacbti+mve
+MULTILIB_MATCHES	+= march?armv8.1-m.main+pacbti+mve=mlibarch?armv8.1-m.main+pacbti+dsp+mve
+MULTILIB_MATCHES	+= march?armv8.1-m.main+pacbti+mve=mlibarch?armv8.1-m.main+dsp+pacbti+mve
+
+MULTILIB_MATCHES	+= $(foreach OPT, $(pacbti_fp_variants), \
+			     march?armv8.1-m.main+pacbti+fp=mlibarch?armv8.1-m.main+pacbti+$(OPT))
+
+MULTILIB_MATCHES	+= $(foreach OPT, $(pacbti_fp_variants), \
+			     march?armv8.1-m.main+pacbti+fp=mlibarch?armv8.1-m.main+pacbti+dsp+$(OPT))
+
+MULTILIB_MATCHES	+= $(foreach OPT, $(pacbti_dp_variants), \
+			     march?armv8.1-m.main+pacbti+fp.dp=mlibarch?armv8.1-m.main+pacbti+$(OPT))
+
+MULTILIB_MATCHES	+= $(foreach OPT, $(pacbti_dp_variants), \
+			     march?armv8.1-m.main+pacbti+fp.dp=mlibarch?armv8.1-m.main+pacbti+dsp+$(OPT))
+
+MULTILIB_MATCHES	+= $(foreach OPT, $(pacbti_fp_variants), \
+			     march?armv8.1-m.main+pacbti+fp=mlibarch?armv8.1-m.main+dsp+pacbti+$(OPT))
+
+MULTILIB_MATCHES	+= $(foreach OPT, $(pacbti_dp_variants), \
+			     march?armv8.1-m.main+pacbti+fp.dp=mlibarch?armv8.1-m.main+dsp+pacbti+$(OPT))
diff --git a/gcc/config/arm/unspecs.md b/gcc/config/arm/unspecs.md
index 2ef6a0f..50e1ac7 100644
--- a/gcc/config/arm/unspecs.md
+++ b/gcc/config/arm/unspecs.md
@@ -159,6 +159,7 @@
   UNSPEC_VCDE		; Custom Datapath Extension instruction.
   UNSPEC_VCDEA		; Custom Datapath Extension instruction.
   UNSPEC_DLS		; Used for DLS (Do Loop Start), Armv8.1-M Mainline instruction
+  UNSPEC_PAC_NOP	; Represents PAC signing LR
 ])
 
 
@@ -254,6 +255,9 @@
 			; instruction.
   VUNSPEC_VLLDM		; Represent the lazy load multiple with vlldm
 			; instruction.
+  VUNSPEC_PACBTI_NOP	; Represents PAC signing LR + valid landing pad
+  VUNSPEC_AUT_NOP	; Represents PAC verifying LR
+  VUNSPEC_BTI_NOP	; Represent BTI
 ])
 
 ;; Enumerators for NEON unspecs.
diff --git a/gcc/config/bpf/bpf.cc b/gcc/config/bpf/bpf.cc
index 576a1fe8..b268801 100644
--- a/gcc/config/bpf/bpf.cc
+++ b/gcc/config/bpf/bpf.cc
@@ -253,6 +253,14 @@ bpf_option_override (void)
   if (bpf_has_jmp32 == -1)
     bpf_has_jmp32 = (bpf_isa >= ISA_V3);
 
+  /* Disable -fstack-protector as it is not supported in BPF.  */
+  if (flag_stack_protect)
+    {
+      inform (input_location,
+              "%<-fstack-protector%> does not work "
+              " on this architecture");
+      flag_stack_protect = 0;
+    }
 }
 
 #undef TARGET_OPTION_OVERRIDE
diff --git a/gcc/config/csky/csky-linux-elf.h b/gcc/config/csky/csky-linux-elf.h
index 3f67af6..117c2a1 100644
--- a/gcc/config/csky/csky-linux-elf.h
+++ b/gcc/config/csky/csky-linux-elf.h
@@ -65,6 +65,8 @@
 
 #define GLIBC_DYNAMIC_LINKER "/lib/ld-linux-cskyv2%{mfloat-abi=hard:-hf}%{mbig-endian:-be}.so.1"
 
+#ifdef CSKY_ENABLE_MULTILIB
+#undef SYSROOT_SUFFIX_SPEC
 #define SYSROOT_SUFFIX_SPEC					\
   "%{mbig-endian:/big}"						\
   "%{mcpu=ck807*:/ck807}"					\
@@ -72,6 +74,7 @@
   "%{mcpu=ck800*:/ck800}"					\
   "%{mfloat-abi=softfp:/soft-fp}"				\
   "%{mfloat-abi=hard:/hard-fp}"
+#endif
 
 #define LINUX_TARGET_LINK_SPEC	"%{h*} %{version:-v}		\
    %{b}								\
diff --git a/gcc/config/i386/avx512erintrin.h b/gcc/config/i386/avx512erintrin.h
index 7d6aecb..bd83b7f 100644
--- a/gcc/config/i386/avx512erintrin.h
+++ b/gcc/config/i386/avx512erintrin.h
@@ -51,9 +51,8 @@ extern __inline __m512d
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_exp2a23_round_pd (__m512d __A, int __R)
 {
-  __m512d __W;
   return (__m512d) __builtin_ia32_exp2pd_mask ((__v8df) __A,
-					       (__v8df) __W,
+					       (__v8df) _mm512_undefined_pd (),
 					       (__mmask8) -1, __R);
 }
 
@@ -79,9 +78,8 @@ extern __inline __m512
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_exp2a23_round_ps (__m512 __A, int __R)
 {
-  __m512 __W;
   return (__m512) __builtin_ia32_exp2ps_mask ((__v16sf) __A,
-					      (__v16sf) __W,
+					      (__v16sf) _mm512_undefined_ps (),
 					      (__mmask16) -1, __R);
 }
 
@@ -107,9 +105,8 @@ extern __inline __m512d
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_rcp28_round_pd (__m512d __A, int __R)
 {
-  __m512d __W;
   return (__m512d) __builtin_ia32_rcp28pd_mask ((__v8df) __A,
-						(__v8df) __W,
+						(__v8df) _mm512_undefined_pd (),
 						(__mmask8) -1, __R);
 }
 
@@ -135,9 +132,8 @@ extern __inline __m512
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_rcp28_round_ps (__m512 __A, int __R)
 {
-  __m512 __W;
   return (__m512) __builtin_ia32_rcp28ps_mask ((__v16sf) __A,
-					       (__v16sf) __W,
+					       (__v16sf) _mm512_undefined_ps (),
 					       (__mmask16) -1, __R);
 }
 
@@ -229,9 +225,8 @@ extern __inline __m512d
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_rsqrt28_round_pd (__m512d __A, int __R)
 {
-  __m512d __W;
   return (__m512d) __builtin_ia32_rsqrt28pd_mask ((__v8df) __A,
-						  (__v8df) __W,
+						  (__v8df) _mm512_undefined_pd (),
 						  (__mmask8) -1, __R);
 }
 
@@ -257,9 +252,8 @@ extern __inline __m512
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_rsqrt28_round_ps (__m512 __A, int __R)
 {
-  __m512 __W;
   return (__m512) __builtin_ia32_rsqrt28ps_mask ((__v16sf) __A,
-						 (__v16sf) __W,
+						 (__v16sf) _mm512_undefined_ps (),
 						 (__mmask16) -1, __R);
 }
 
diff --git a/gcc/config/i386/cygwin.h b/gcc/config/i386/cygwin.h
index 4f219fb..b2c45ab 100644
--- a/gcc/config/i386/cygwin.h
+++ b/gcc/config/i386/cygwin.h
@@ -48,7 +48,7 @@ along with GCC; see the file COPYING3.  If not see
 
 #undef ENDFILE_SPEC
 #define ENDFILE_SPEC \
-  "%{Ofast|ffast-math|funsafe-math-optimizations:crtfastmath.o%s}\
+  "%{mdaz-ftz:crtfastmath.o%s;Ofast|ffast-math|funsafe-math-optimizations:%{!shared:%{!mno-daz-ftz:crtfastmath.o%s}}} \
    %{!shared:%:if-exists(default-manifest.o%s)}\
    %{fvtable-verify=none:%s; \
     fvtable-verify=preinit:vtv_end.o%s; \
diff --git a/gcc/config/i386/darwin.h b/gcc/config/i386/darwin.h
index 074a648..588bd66 100644
--- a/gcc/config/i386/darwin.h
+++ b/gcc/config/i386/darwin.h
@@ -110,7 +110,7 @@ along with GCC; see the file COPYING3.  If not see
 
 #undef ENDFILE_SPEC
 #define ENDFILE_SPEC \
-  "%{Ofast|ffast-math|funsafe-math-optimizations:crtfastmath.o%s} \
+  "%{mdaz-ftz:crtfastmath.o%s;Ofast|ffast-math|funsafe-math-optimizations:%{!shared:%{!mno-daz-ftz:crtfastmath.o%s}}} \
    %{mpc32:crtprec32.o%s} \
    %{mpc64:crtprec64.o%s} \
    %{mpc80:crtprec80.o%s}" TM_DESTRUCTOR
diff --git a/gcc/config/i386/gnu64.h b/gcc/config/i386/gnu64.h
new file mode 100644
index 0000000..a411f0e
--- /dev/null
+++ b/gcc/config/i386/gnu64.h
@@ -0,0 +1,40 @@
+/* Configuration for an x86_64 running GNU with ELF as the target machine.  */
+
+/*
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+GCC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#define GNU_USER_LINK_EMULATION32 "elf_i386"
+#define GNU_USER_LINK_EMULATION64 "elf_x86_64"
+#define GNU_USER_LINK_EMULATIONX32 "elf32_x86_64"
+
+#undef GNU_USER_DYNAMIC_LINKER
+#define GNU_USER_DYNAMIC_LINKER32 "/lib/ld.so.1"
+#define GNU_USER_DYNAMIC_LINKER64 "/lib/ld-x86-64.so.1"
+#define GNU_USER_DYNAMIC_LINKERX32 "/lib/ld-x32.so.1"
+
+#undef	STARTFILE_SPEC
+#if defined HAVE_LD_PIE
+#define STARTFILE_SPEC \
+  "%{!shared: %{pg|p|profile:%{static:gcrt0.o%s;:gcrt1.o%s};pie:Scrt1.o%s;static:crt0.o%s;:crt1.o%s}} \
+   crti.o%s %{static:crtbeginT.o%s;shared|pie:crtbeginS.o%s;:crtbegin.o%s}"
+#else
+#define STARTFILE_SPEC \
+  "%{!shared: %{pg|p|profile:%{static:gcrt0.o%s;:gcrt1.o%s};static:crt0.o%s;:crt1.o%s}} \
+   crti.o%s %{static:crtbeginT.o%s;shared|pie:crtbeginS.o%s;:crtbegin.o%s}"
+#endif
diff --git a/gcc/config/i386/i386-expand.cc b/gcc/config/i386/i386-expand.cc
index 54f700c..e59c7b0 100644
--- a/gcc/config/i386/i386-expand.cc
+++ b/gcc/config/i386/i386-expand.cc
@@ -291,7 +291,9 @@ ix86_convert_const_wide_int_to_broadcast (machine_mode mode, rtx op)
      broadcast only if vector broadcast is available.  */
   if (!TARGET_AVX
       || !CONST_WIDE_INT_P (op)
-      || standard_sse_constant_p (op, mode))
+      || standard_sse_constant_p (op, mode)
+      || (CONST_WIDE_INT_NUNITS (op) * HOST_BITS_PER_WIDE_INT
+	  != GET_MODE_BITSIZE (mode)))
     return nullptr;
 
   HOST_WIDE_INT val = CONST_WIDE_INT_ELT (op, 0);
@@ -13175,6 +13177,12 @@ ix86_expand_builtin (tree exp, rtx target, rtx subtarget,
 
 	if (INTVAL (op3) == 1)
 	  {
+	    if (INTVAL (op2) < 2 || INTVAL (op2) > 3)
+	      {
+		error ("invalid third argument");
+		return const0_rtx;
+	      }
+
 	    if (TARGET_64BIT && TARGET_PREFETCHI
 		&& local_func_symbolic_operand (op0, GET_MODE (op0)))
 	      emit_insn (gen_prefetchi (op0, op2));
@@ -13195,6 +13203,12 @@ ix86_expand_builtin (tree exp, rtx target, rtx subtarget,
 		op0 = copy_addr_to_reg (op0);
 	      }
 
+	    if (INTVAL (op2) < 0 || INTVAL (op2) > 3)
+	      {
+		warning (0, "invalid third argument to %<__builtin_ia32_prefetch%>; using zero");
+		op2 = const0_rtx;
+	      }
+
 	    if (TARGET_3DNOW || TARGET_PREFETCH_SSE
 		|| TARGET_PRFCHW || TARGET_PREFETCHWT1)
 	      emit_insn (gen_prefetch (op0, op1, op2));
diff --git a/gcc/config/i386/i386.cc b/gcc/config/i386/i386.cc
index d80164f..3cacf73 100644
--- a/gcc/config/i386/i386.cc
+++ b/gcc/config/i386/i386.cc
@@ -19051,6 +19051,13 @@ ix86_vectorize_builtin_scatter (const_tree vectype,
   if (!TARGET_AVX512F)
     return NULL_TREE;
 
+  if (known_eq (TYPE_VECTOR_SUBPARTS (vectype), 2u)
+      ? !TARGET_USE_SCATTER_2PARTS
+      : (known_eq (TYPE_VECTOR_SUBPARTS (vectype), 4u)
+	 ? !TARGET_USE_SCATTER_4PARTS
+	 : !TARGET_USE_SCATTER))
+    return NULL_TREE;
+
   if ((TREE_CODE (index_type) != INTEGER_TYPE
        && !POINTER_TYPE_P (index_type))
       || (TYPE_MODE (index_type) != SImode
@@ -21473,6 +21480,7 @@ x86_output_mi_thunk (FILE *file, tree thunk_fndecl, HOST_WIDE_INT delta,
   rtx this_reg, tmp, fnaddr;
   unsigned int tmp_regno;
   rtx_insn *insn;
+  int saved_flag_force_indirect_call = flag_force_indirect_call;
 
   if (TARGET_64BIT)
     tmp_regno = R10_REG;
@@ -21485,6 +21493,9 @@ x86_output_mi_thunk (FILE *file, tree thunk_fndecl, HOST_WIDE_INT delta,
 	tmp_regno = DX_REG;
       else
 	tmp_regno = CX_REG;
+
+      if (flag_pic)
+  flag_force_indirect_call = 0;
     }
 
   emit_note (NOTE_INSN_PROLOGUE_END);
@@ -21652,6 +21663,8 @@ x86_output_mi_thunk (FILE *file, tree thunk_fndecl, HOST_WIDE_INT delta,
   final (insn, file, 1);
   final_end_function ();
   assemble_end_function (thunk_fndecl, fnname);
+
+  flag_force_indirect_call = saved_flag_force_indirect_call;
 }
 
 static void
diff --git a/gcc/config/i386/i386.h b/gcc/config/i386/i386.h
index 0ee6450..dd9391c 100644
--- a/gcc/config/i386/i386.h
+++ b/gcc/config/i386/i386.h
@@ -397,10 +397,16 @@ extern unsigned char ix86_tune_features[X86_TUNE_LAST];
 	ix86_tune_features[X86_TUNE_AVOID_4BYTE_PREFIXES]
 #define TARGET_USE_GATHER_2PARTS \
 	ix86_tune_features[X86_TUNE_USE_GATHER_2PARTS]
+#define TARGET_USE_SCATTER_2PARTS \
+	ix86_tune_features[X86_TUNE_USE_SCATTER_2PARTS]
 #define TARGET_USE_GATHER_4PARTS \
 	ix86_tune_features[X86_TUNE_USE_GATHER_4PARTS]
+#define TARGET_USE_SCATTER_4PARTS \
+	ix86_tune_features[X86_TUNE_USE_SCATTER_4PARTS]
 #define TARGET_USE_GATHER \
 	ix86_tune_features[X86_TUNE_USE_GATHER]
+#define TARGET_USE_SCATTER \
+	ix86_tune_features[X86_TUNE_USE_SCATTER]
 #define TARGET_FUSE_CMP_AND_BRANCH_32 \
 	ix86_tune_features[X86_TUNE_FUSE_CMP_AND_BRANCH_32]
 #define TARGET_FUSE_CMP_AND_BRANCH_64 \
diff --git a/gcc/config/i386/i386.opt b/gcc/config/i386/i386.opt
index feeb7de..7d57f61 100644
--- a/gcc/config/i386/i386.opt
+++ b/gcc/config/i386/i386.opt
@@ -1209,7 +1209,7 @@ Support MWAIT and MONITOR built-in functions and code generation.
 
 mavx512fp16
 Target Mask(ISA2_AVX512FP16) Var(ix86_isa_flags2) Save
-Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2, AVX512F and AVX512FP16 built-in functions and code generation.
+Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2, AVX512F and AVX512-FP16 built-in functions and code generation.
 
 mdirect-extern-access
 Target Var(ix86_direct_extern_access) Init(1)
diff --git a/gcc/config/i386/mingw32.h b/gcc/config/i386/mingw32.h
index f7379de..6a55baa 100644
--- a/gcc/config/i386/mingw32.h
+++ b/gcc/config/i386/mingw32.h
@@ -196,7 +196,7 @@ along with GCC; see the file COPYING3.  If not see
 
 #undef ENDFILE_SPEC
 #define ENDFILE_SPEC \
-  "%{Ofast|ffast-math|funsafe-math-optimizations:crtfastmath.o%s} \
+  "%{mdaz-ftz:crtfastmath.o%s;Ofast|ffast-math|funsafe-math-optimizations:%{!shared:%{!mno-daz-ftz:crtfastmath.o%s}}} \
    %{!shared:%:if-exists(default-manifest.o%s)}\
    %{fvtable-verify=none:%s; \
     fvtable-verify=preinit:vtv_end.o%s; \
diff --git a/gcc/config/i386/x86-tune.def b/gcc/config/i386/x86-tune.def
index 1b754d5..c78dad0 100644
--- a/gcc/config/i386/x86-tune.def
+++ b/gcc/config/i386/x86-tune.def
@@ -483,28 +483,43 @@ DEF_TUNE (X86_TUNE_AVOID_4BYTE_PREFIXES, "avoid_4byte_prefixes",
 DEF_TUNE (X86_TUNE_USE_GATHER_2PARTS, "use_gather_2parts",
 	  ~(m_ZNVER1 | m_ZNVER2 | m_ZNVER3 | m_ZNVER4 | m_ALDERLAKE | m_CORE_ATOM | m_GENERIC))
 
+/* X86_TUNE_USE_SCATTER_2PARTS: Use scater instructions for vectors with 2
+   elements.  */
+DEF_TUNE (X86_TUNE_USE_SCATTER_2PARTS, "use_scatter_2parts",
+	  ~(m_ZNVER4 | m_GENERIC))
+
 /* X86_TUNE_USE_GATHER_4PARTS: Use gather instructions for vectors with 4
    elements.  */
 DEF_TUNE (X86_TUNE_USE_GATHER_4PARTS, "use_gather_4parts",
 	  ~(m_ZNVER1 | m_ZNVER2 | m_ZNVER3 | m_ZNVER4 | m_ALDERLAKE | m_CORE_ATOM | m_GENERIC))
 
+/* X86_TUNE_USE_SCATTER_4PARTS: Use scater instructions for vectors with 4
+   elements.  */
+DEF_TUNE (X86_TUNE_USE_SCATTER_4PARTS, "use_scatter_4parts",
+	  ~(m_ZNVER4 | m_GENERIC))
+
 /* X86_TUNE_USE_GATHER: Use gather instructions for vectors with 8 or more
    elements.  */
 DEF_TUNE (X86_TUNE_USE_GATHER, "use_gather",
-	  ~(m_ZNVER1 | m_ZNVER2 | m_ALDERLAKE | m_CORE_ATOM | m_GENERIC))
+	  ~(m_ZNVER1 | m_ZNVER2 | m_ZNVER4 | m_ALDERLAKE | m_CORE_ATOM | m_GENERIC))
+
+/* X86_TUNE_USE_SCATTER: Use scater instructions for vectors with 8 or more
+   elements.  */
+DEF_TUNE (X86_TUNE_USE_SCATTER, "use_scatter",
+	  ~(m_ZNVER4 | m_GENERIC))
 
 /* X86_TUNE_AVOID_128FMA_CHAINS: Avoid creating loops with tight 128bit or
    smaller FMA chain.  */
-DEF_TUNE (X86_TUNE_AVOID_128FMA_CHAINS, "avoid_fma_chains", m_ZNVER)
+DEF_TUNE (X86_TUNE_AVOID_128FMA_CHAINS, "avoid_fma_chains", m_ZNVER1 | m_ZNVER2 | m_ZNVER3)
 
 /* X86_TUNE_AVOID_256FMA_CHAINS: Avoid creating loops with tight 256bit or
    smaller FMA chain.  */
-DEF_TUNE (X86_TUNE_AVOID_256FMA_CHAINS, "avoid_fma256_chains", m_ZNVER2 | m_ZNVER3 | m_ZNVER4
+DEF_TUNE (X86_TUNE_AVOID_256FMA_CHAINS, "avoid_fma256_chains", m_ZNVER2 | m_ZNVER3
 	  | m_ALDERLAKE | m_SAPPHIRERAPIDS | m_CORE_ATOM)
 
 /* X86_TUNE_AVOID_512FMA_CHAINS: Avoid creating loops with tight 512bit or
    smaller FMA chain.  */
-DEF_TUNE (X86_TUNE_AVOID_512FMA_CHAINS, "avoid_fma512_chains", m_ZNVER4)
+DEF_TUNE (X86_TUNE_AVOID_512FMA_CHAINS, "avoid_fma512_chains", m_NONE)
 
 /* X86_TUNE_V2DF_REDUCTION_PREFER_PHADDPD: Prefer haddpd
    for v2df vector reduction.  */
diff --git a/gcc/config/ia64/linux.h b/gcc/config/ia64/linux.h
index b907cf0..5dfd428 100644
--- a/gcc/config/ia64/linux.h
+++ b/gcc/config/ia64/linux.h
@@ -49,7 +49,7 @@ do {						\
 /* Similar to standard Linux, but adding -ffast-math support.  */
 #undef  ENDFILE_SPEC
 #define ENDFILE_SPEC \
-  "%{Ofast|ffast-math|funsafe-math-optimizations:crtfastmath.o%s} \
+  "%{Ofast|ffast-math|funsafe-math-optimizations:%{!shared:crtfastmath.o%s}} \
    %{shared|pie:crtendS.o%s;:crtend.o%s} crtn.o%s"
 
 /* Define this for shared library support because it isn't in the main
diff --git a/gcc/config/loongarch/gnu-user.h b/gcc/config/loongarch/gnu-user.h
index fb7106f..aecaa02 100644
--- a/gcc/config/loongarch/gnu-user.h
+++ b/gcc/config/loongarch/gnu-user.h
@@ -49,7 +49,7 @@ along with GCC; see the file COPYING3.  If not see
 /* Similar to standard Linux, but adding -ffast-math support.  */
 #undef GNU_USER_TARGET_MATHFILE_SPEC
 #define GNU_USER_TARGET_MATHFILE_SPEC \
-  "%{Ofast|ffast-math|funsafe-math-optimizations:crtfastmath.o%s}"
+  "%{Ofast|ffast-math|funsafe-math-optimizations:%{!shared:crtfastmath.o%s}}"
 
 #undef LIB_SPEC
 #define LIB_SPEC GNU_USER_TARGET_LIB_SPEC
diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc
index 2443966..6927bdc 100644
--- a/gcc/config/loongarch/loongarch.cc
+++ b/gcc/config/loongarch/loongarch.cc
@@ -2075,6 +2075,11 @@ loongarch_classify_address (struct loongarch_address_info *info, rtx x,
       return (loongarch_valid_base_register_p (info->reg, mode, strict_p)
 	      && loongarch_valid_lo_sum_p (info->symbol_type, mode,
 					   info->offset));
+    case CONST_INT:
+      /* Small-integer addresses don't occur very often, but they
+	 are legitimate if $r0 is a valid base register.  */
+      info->type = ADDRESS_CONST_INT;
+      return IMM12_OPERAND (INTVAL (x));
 
     default:
       return false;
@@ -4933,6 +4938,7 @@ loongarch_print_operand_reloc (FILE *file, rtx op, bool hi64_part,
 
    'A'	Print a _DB suffix if the memory model requires a release.
    'b'	Print the address of a memory operand, without offset.
+   'c'  Print an integer.
    'C'	Print the integer branch condition for comparison OP.
    'd'	Print CONST_INT OP in decimal.
    'F'	Print the FPU branch condition for comparison OP.
@@ -4979,6 +4985,14 @@ loongarch_print_operand (FILE *file, rtx op, int letter)
        fputs ("_db", file);
       break;
 
+    case 'c':
+      if (CONST_INT_P (op))
+	fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (op));
+      else
+	output_operand_lossage ("unsupported operand for code '%c'", letter);
+
+      break;
+
     case 'C':
       loongarch_print_int_branch_condition (file, code, letter);
       break;
diff --git a/gcc/config/mips/gnu-user.h b/gcc/config/mips/gnu-user.h
index 9a540b8..a4e5380 100644
--- a/gcc/config/mips/gnu-user.h
+++ b/gcc/config/mips/gnu-user.h
@@ -139,7 +139,7 @@ extern const char *host_detect_local_cpu (int argc, const char **argv);
 /* Similar to standard Linux, but adding -ffast-math support.  */
 #undef	GNU_USER_TARGET_MATHFILE_SPEC
 #define GNU_USER_TARGET_MATHFILE_SPEC \
-  "%{Ofast|ffast-math|funsafe-math-optimizations:crtfastmath.o%s}"
+  "%{Ofast|ffast-math|funsafe-math-optimizations:%{!shared:crtfastmath.o%s}}"
 #undef  ENDFILE_SPEC
 #define ENDFILE_SPEC \
   GNU_USER_TARGET_MATHFILE_SPEC " " \
diff --git a/gcc/config/pru/pru.h b/gcc/config/pru/pru.h
index 3658036..1b5e874 100644
--- a/gcc/config/pru/pru.h
+++ b/gcc/config/pru/pru.h
@@ -566,8 +566,9 @@ do {									\
 
 #define CASE_VECTOR_MODE Pmode
 
-/* See definition of clz pattern for rationale of value -1.  */
-#define CLZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) ((VALUE) = -1, 2)
+/* See definition of clz pattern for rationale of the value.  */
+#define CLZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE)	\
+	((VALUE) = GET_MODE_BITSIZE (MODE) - 1 - 32, 2)
 
 /* Jumps are cheap on PRU.  */
 #define LOGICAL_OP_NON_SHORT_CIRCUIT		0
diff --git a/gcc/config/pru/pru.md b/gcc/config/pru/pru.md
index dfe0807..6deb5ec 100644
--- a/gcc/config/pru/pru.md
+++ b/gcc/config/pru/pru.md
@@ -1723,8 +1723,16 @@
   [(set_attr "type" "control")])
 
 ;; Count Leading Zeros implemented using LMBD.
-;; LMBD returns 32 if bit value is not present, and we subtract 31 to get CLZ.
-;; Hence we get a defined value -1 for CLZ_DEFINED_VALUE_AT_ZERO.
+;;
+;; LMBD returns 32 if bit value is not present, for any kind of input MODE.
+;; The LMBD's search result for a "1" bit is subtracted from the
+;; mode bit size minus one, in order to get CLZ.
+;;
+;; Hence for SImode we get a defined value -1 for CLZ_DEFINED_VALUE_AT_ZERO.
+;;
+;; The QImode and HImode defined values for zero inputs end up to be
+;; non-standard (-25 and -17).  But this is considered acceptable in
+;; order to keep the CLZ expansion to only two instructions.
 (define_expand "clz<mode>2"
   [(set (match_operand:QISI 0 "register_operand")
 	(clz:QISI (match_operand:QISI 1 "register_operand")))]
@@ -1735,7 +1743,8 @@
   rtx tmpval = gen_reg_rtx (<MODE>mode);
 
   emit_insn (gen_pru_lmbd (<MODE>mode, tmpval, src, const1_rtx));
-  emit_insn (gen_sub3_insn (dst, GEN_INT (31), tmpval));
+  int msb_bitn = GET_MODE_BITSIZE (<MODE>mode) - 1;
+  emit_insn (gen_sub3_insn (dst, GEN_INT (msb_bitn), tmpval));
   DONE;
 })
 
diff --git a/gcc/config/riscv/predicates.md b/gcc/config/riscv/predicates.md
index 766a427..f9013bb 100644
--- a/gcc/config/riscv/predicates.md
+++ b/gcc/config/riscv/predicates.md
@@ -286,6 +286,10 @@
 	    (match_test "GET_CODE (op) == UNSPEC
 			 && (XINT (op, 1) == UNSPEC_VUNDEF)"))))
 
+(define_special_predicate "pmode_reg_or_0_operand"
+  (ior (match_operand 0 "const_0_operand")
+       (match_operand 0 "pmode_register_operand")))
+
 ;; The scalar operand can be directly broadcast by RVV instructions.
 (define_predicate "direct_broadcast_operand"
   (ior (match_operand 0 "register_operand")
diff --git a/gcc/config/riscv/riscv-passes.def b/gcc/config/riscv/riscv-passes.def
index e68de68..4084122 100644
--- a/gcc/config/riscv/riscv-passes.def
+++ b/gcc/config/riscv/riscv-passes.def
@@ -18,4 +18,4 @@
    <http://www.gnu.org/licenses/>.  */
 
 INSERT_PASS_AFTER (pass_rtl_store_motion, 1, pass_shorten_memrefs);
-INSERT_PASS_BEFORE (pass_sched2, 1, pass_vsetvl);
+INSERT_PASS_BEFORE (pass_fast_rtl_dce, 1, pass_vsetvl);
diff --git a/gcc/config/riscv/riscv-protos.h b/gcc/config/riscv/riscv-protos.h
index 1facad7..ceae400 100644
--- a/gcc/config/riscv/riscv-protos.h
+++ b/gcc/config/riscv/riscv-protos.h
@@ -172,6 +172,7 @@ enum mask_policy
 enum tail_policy get_prefer_tail_policy ();
 enum mask_policy get_prefer_mask_policy ();
 rtx get_avl_type_rtx (enum avl_type);
+opt_machine_mode get_vector_mode (scalar_mode, poly_uint64);
 }
 
 /* We classify builtin types into two classes:
diff --git a/gcc/config/riscv/riscv-v.cc b/gcc/config/riscv/riscv-v.cc
index 47f2cef..992b343 100644
--- a/gcc/config/riscv/riscv-v.cc
+++ b/gcc/config/riscv/riscv-v.cc
@@ -349,4 +349,26 @@ get_avl_type_rtx (enum avl_type type)
   return gen_int_mode (type, Pmode);
 }
 
+/* Return the RVV vector mode that has NUNITS elements of mode INNER_MODE.
+   This function is not only used by builtins, but also will be used by
+   auto-vectorization in the future.  */
+opt_machine_mode
+get_vector_mode (scalar_mode inner_mode, poly_uint64 nunits)
+{
+  enum mode_class mclass;
+  if (inner_mode == E_BImode)
+    mclass = MODE_VECTOR_BOOL;
+  else if (FLOAT_MODE_P (inner_mode))
+    mclass = MODE_VECTOR_FLOAT;
+  else
+    mclass = MODE_VECTOR_INT;
+  machine_mode mode;
+  FOR_EACH_MODE_IN_CLASS (mode, mclass)
+    if (inner_mode == GET_MODE_INNER (mode)
+	&& known_eq (nunits, GET_MODE_NUNITS (mode))
+	&& riscv_v_ext_vector_mode_p (mode))
+      return mode;
+  return opt_machine_mode ();
+}
+
 } // namespace riscv_vector
diff --git a/gcc/config/riscv/riscv-vector-builtins-bases.cc b/gcc/config/riscv/riscv-vector-builtins-bases.cc
index ee923da..129e89f 100644
--- a/gcc/config/riscv/riscv-vector-builtins-bases.cc
+++ b/gcc/config/riscv/riscv-vector-builtins-bases.cc
@@ -48,6 +48,16 @@ using namespace riscv_vector;
 
 namespace riscv_vector {
 
+/* Enumerates types of loads/stores operations.
+   It's only used in here so we don't define it
+   in riscv-vector-builtins-bases.h.  */
+enum lst_type
+{
+  LST_UNIT_STRIDE,
+  LST_STRIDED,
+  LST_INDEXED,
+};
+
 /* Implements vsetvl<mode> && vsetvlmax<mode>.  */
 template<bool VLMAX_P>
 class vsetvl : public function_base
@@ -84,10 +94,16 @@ public:
   }
 };
 
-/* Implements vle.v/vse.v codegen.  */
-template <bool STORE_P>
+/* Implements
+ * vle.v/vse.v/vlm.v/vsm.v/vlse.v/vsse.v/vluxei.v/vloxei.v/vsuxei.v/vsoxei.v
+ * codegen.  */
+template<bool STORE_P, lst_type LST_TYPE, bool ORDERED_P>
 class loadstore : public function_base
 {
+public:
+  bool apply_tail_policy_p () const override { return !STORE_P; }
+  bool apply_mask_policy_p () const override { return !STORE_P; }
+
   unsigned int call_properties (const function_instance &) const override
   {
     if (STORE_P)
@@ -98,24 +114,70 @@ class loadstore : public function_base
 
   bool can_be_overloaded_p (enum predication_type_index pred) const override
   {
-    if (STORE_P)
+    if (STORE_P || LST_TYPE == LST_INDEXED)
       return true;
     return pred != PRED_TYPE_none && pred != PRED_TYPE_mu;
   }
 
   rtx expand (function_expander &e) const override
   {
-    if (STORE_P)
-      return e.use_contiguous_store_insn (code_for_pred_mov (e.vector_mode ()));
+    if (LST_TYPE == LST_INDEXED)
+      {
+	int unspec = ORDERED_P ? UNSPEC_ORDERED : UNSPEC_UNORDERED;
+	if (STORE_P)
+	  return e.use_exact_insn (
+	    code_for_pred_indexed_store (unspec, e.vector_mode (),
+					 e.index_mode ()));
+	else
+	  return e.use_exact_insn (
+	    code_for_pred_indexed_load (unspec, e.vector_mode (),
+					e.index_mode ()));
+      }
+    else if (LST_TYPE == LST_STRIDED)
+      {
+	if (STORE_P)
+	  return e.use_contiguous_store_insn (
+	    code_for_pred_strided_store (e.vector_mode ()));
+	else
+	  return e.use_contiguous_load_insn (
+	    code_for_pred_strided_load (e.vector_mode ()));
+      }
     else
-      return e.use_contiguous_load_insn (code_for_pred_mov (e.vector_mode ()));
+      {
+	if (STORE_P)
+	  return e.use_contiguous_store_insn (
+	    code_for_pred_store (e.vector_mode ()));
+	else
+	  return e.use_contiguous_load_insn (
+	    code_for_pred_mov (e.vector_mode ()));
+      }
   }
 };
 
 static CONSTEXPR const vsetvl<false> vsetvl_obj;
 static CONSTEXPR const vsetvl<true> vsetvlmax_obj;
-static CONSTEXPR const loadstore<false> vle_obj;
-static CONSTEXPR const loadstore<true> vse_obj;
+static CONSTEXPR const loadstore<false, LST_UNIT_STRIDE, false> vle_obj;
+static CONSTEXPR const loadstore<true, LST_UNIT_STRIDE, false> vse_obj;
+static CONSTEXPR const loadstore<false, LST_UNIT_STRIDE, false> vlm_obj;
+static CONSTEXPR const loadstore<true, LST_UNIT_STRIDE, false> vsm_obj;
+static CONSTEXPR const loadstore<false, LST_STRIDED, false> vlse_obj;
+static CONSTEXPR const loadstore<true, LST_STRIDED, false> vsse_obj;
+static CONSTEXPR const loadstore<false, LST_INDEXED, false> vluxei8_obj;
+static CONSTEXPR const loadstore<false, LST_INDEXED, false> vluxei16_obj;
+static CONSTEXPR const loadstore<false, LST_INDEXED, false> vluxei32_obj;
+static CONSTEXPR const loadstore<false, LST_INDEXED, false> vluxei64_obj;
+static CONSTEXPR const loadstore<false, LST_INDEXED, true> vloxei8_obj;
+static CONSTEXPR const loadstore<false, LST_INDEXED, true> vloxei16_obj;
+static CONSTEXPR const loadstore<false, LST_INDEXED, true> vloxei32_obj;
+static CONSTEXPR const loadstore<false, LST_INDEXED, true> vloxei64_obj;
+static CONSTEXPR const loadstore<true, LST_INDEXED, false> vsuxei8_obj;
+static CONSTEXPR const loadstore<true, LST_INDEXED, false> vsuxei16_obj;
+static CONSTEXPR const loadstore<true, LST_INDEXED, false> vsuxei32_obj;
+static CONSTEXPR const loadstore<true, LST_INDEXED, false> vsuxei64_obj;
+static CONSTEXPR const loadstore<true, LST_INDEXED, true> vsoxei8_obj;
+static CONSTEXPR const loadstore<true, LST_INDEXED, true> vsoxei16_obj;
+static CONSTEXPR const loadstore<true, LST_INDEXED, true> vsoxei32_obj;
+static CONSTEXPR const loadstore<true, LST_INDEXED, true> vsoxei64_obj;
 
 /* Declare the function base NAME, pointing it to an instance
    of class <NAME>_obj.  */
@@ -126,5 +188,25 @@ BASE (vsetvl)
 BASE (vsetvlmax)
 BASE (vle)
 BASE (vse)
+BASE (vlm)
+BASE (vsm)
+BASE (vlse)
+BASE (vsse)
+BASE (vluxei8)
+BASE (vluxei16)
+BASE (vluxei32)
+BASE (vluxei64)
+BASE (vloxei8)
+BASE (vloxei16)
+BASE (vloxei32)
+BASE (vloxei64)
+BASE (vsuxei8)
+BASE (vsuxei16)
+BASE (vsuxei32)
+BASE (vsuxei64)
+BASE (vsoxei8)
+BASE (vsoxei16)
+BASE (vsoxei32)
+BASE (vsoxei64)
 
 } // end namespace riscv_vector
diff --git a/gcc/config/riscv/riscv-vector-builtins-bases.h b/gcc/config/riscv/riscv-vector-builtins-bases.h
index 5044f57..238c01d 100644
--- a/gcc/config/riscv/riscv-vector-builtins-bases.h
+++ b/gcc/config/riscv/riscv-vector-builtins-bases.h
@@ -28,6 +28,26 @@ extern const function_base *const vsetvl;
 extern const function_base *const vsetvlmax;
 extern const function_base *const vle;
 extern const function_base *const vse;
+extern const function_base *const vlm;
+extern const function_base *const vsm;
+extern const function_base *const vlse;
+extern const function_base *const vsse;
+extern const function_base *const vluxei8;
+extern const function_base *const vluxei16;
+extern const function_base *const vluxei32;
+extern const function_base *const vluxei64;
+extern const function_base *const vloxei8;
+extern const function_base *const vloxei16;
+extern const function_base *const vloxei32;
+extern const function_base *const vloxei64;
+extern const function_base *const vsuxei8;
+extern const function_base *const vsuxei16;
+extern const function_base *const vsuxei32;
+extern const function_base *const vsuxei64;
+extern const function_base *const vsoxei8;
+extern const function_base *const vsoxei16;
+extern const function_base *const vsoxei32;
+extern const function_base *const vsoxei64;
 }
 
 } // end namespace riscv_vector
diff --git a/gcc/config/riscv/riscv-vector-builtins-functions.def b/gcc/config/riscv/riscv-vector-builtins-functions.def
index 2b4bd47..9719b9b 100644
--- a/gcc/config/riscv/riscv-vector-builtins-functions.def
+++ b/gcc/config/riscv/riscv-vector-builtins-functions.def
@@ -42,5 +42,25 @@ DEF_RVV_FUNCTION (vsetvlmax, vsetvlmax, none_preds, i_none_size_void_ops)
 /* 7. Vector Loads and Stores. */
 DEF_RVV_FUNCTION (vle, loadstore, full_preds, all_v_scalar_const_ptr_ops)
 DEF_RVV_FUNCTION (vse, loadstore, none_m_preds, all_v_scalar_ptr_ops)
+DEF_RVV_FUNCTION (vlm, loadstore, none_preds, b_v_scalar_const_ptr_ops)
+DEF_RVV_FUNCTION (vsm, loadstore, none_preds, b_v_scalar_ptr_ops)
+DEF_RVV_FUNCTION (vlse, loadstore, full_preds, all_v_scalar_const_ptr_ptrdiff_ops)
+DEF_RVV_FUNCTION (vsse, loadstore, none_m_preds, all_v_scalar_ptr_ptrdiff_ops)
+DEF_RVV_FUNCTION (vluxei8, indexed_loadstore, full_preds, all_v_scalar_const_ptr_uint8_index_ops)
+DEF_RVV_FUNCTION (vluxei16, indexed_loadstore, full_preds, all_v_scalar_const_ptr_uint16_index_ops)
+DEF_RVV_FUNCTION (vluxei32, indexed_loadstore, full_preds, all_v_scalar_const_ptr_uint32_index_ops)
+DEF_RVV_FUNCTION (vluxei64, indexed_loadstore, full_preds, all_v_scalar_const_ptr_uint64_index_ops)
+DEF_RVV_FUNCTION (vloxei8, indexed_loadstore, full_preds, all_v_scalar_const_ptr_uint8_index_ops)
+DEF_RVV_FUNCTION (vloxei16, indexed_loadstore, full_preds, all_v_scalar_const_ptr_uint16_index_ops)
+DEF_RVV_FUNCTION (vloxei32, indexed_loadstore, full_preds, all_v_scalar_const_ptr_uint32_index_ops)
+DEF_RVV_FUNCTION (vloxei64, indexed_loadstore, full_preds, all_v_scalar_const_ptr_uint64_index_ops)
+DEF_RVV_FUNCTION (vsuxei8, indexed_loadstore, none_m_preds, all_v_scalar_ptr_uint8_index_ops)
+DEF_RVV_FUNCTION (vsuxei16, indexed_loadstore, none_m_preds, all_v_scalar_ptr_uint16_index_ops)
+DEF_RVV_FUNCTION (vsuxei32, indexed_loadstore, none_m_preds, all_v_scalar_ptr_uint32_index_ops)
+DEF_RVV_FUNCTION (vsuxei64, indexed_loadstore, none_m_preds, all_v_scalar_ptr_uint64_index_ops)
+DEF_RVV_FUNCTION (vsoxei8, indexed_loadstore, none_m_preds, all_v_scalar_ptr_uint8_index_ops)
+DEF_RVV_FUNCTION (vsoxei16, indexed_loadstore, none_m_preds, all_v_scalar_ptr_uint16_index_ops)
+DEF_RVV_FUNCTION (vsoxei32, indexed_loadstore, none_m_preds, all_v_scalar_ptr_uint32_index_ops)
+DEF_RVV_FUNCTION (vsoxei64, indexed_loadstore, none_m_preds, all_v_scalar_ptr_uint64_index_ops)
 
 #undef DEF_RVV_FUNCTION
diff --git a/gcc/config/riscv/riscv-vector-builtins-shapes.cc b/gcc/config/riscv/riscv-vector-builtins-shapes.cc
index e796aa8..d261dfb 100644
--- a/gcc/config/riscv/riscv-vector-builtins-shapes.cc
+++ b/gcc/config/riscv/riscv-vector-builtins-shapes.cc
@@ -116,7 +116,8 @@ struct loadstore_def : public build_base
     machine_mode mode = TYPE_MODE (type);
     int sew = GET_MODE_BITSIZE (GET_MODE_INNER (mode));
     /* vop --> vop<sew>.  */
-    b.append_sew (sew);
+    if (GET_MODE_CLASS (mode) != MODE_VECTOR_BOOL)
+      b.append_sew (sew);
 
     /* vop<sew>_v --> vop<sew>_v_<type>.  */
     if (!overloaded_p)
@@ -127,6 +128,58 @@ struct loadstore_def : public build_base
 	b.append_name (type_suffixes[instance.type.index].vector);
       }
 
+    /* According to rvv-intrinsic-doc, it does not add "_m" suffix
+       for vop_m C++ overloaded API.  */
+    if (overloaded_p && instance.pred == PRED_TYPE_m)
+      return b.finish_name ();
+    b.append_name (predication_suffixes[instance.pred]);
+    return b.finish_name ();
+  }
+};
+
+/* indexed_loadstore_def class.  */
+struct indexed_loadstore_def : public function_shape
+{
+  void build (function_builder &b,
+	      const function_group_info &group) const override
+  {
+    for (unsigned int pred_idx = 0; group.preds[pred_idx] != NUM_PRED_TYPES;
+	 ++pred_idx)
+      {
+	for (unsigned int vec_type_idx = 0;
+	     group.ops_infos.types[vec_type_idx].index != NUM_VECTOR_TYPES;
+	     ++vec_type_idx)
+	  {
+	    tree index_type = group.ops_infos.args[1].get_tree_type (
+	      group.ops_infos.types[vec_type_idx].index);
+	    if (!index_type)
+	      continue;
+	    build_one (b, group, pred_idx, vec_type_idx);
+	  }
+      }
+  }
+
+  char *get_name (function_builder &b, const function_instance &instance,
+		  bool overloaded_p) const override
+  {
+    /* Return nullptr if it can not be overloaded.  */
+    if (overloaded_p && !instance.base->can_be_overloaded_p (instance.pred))
+      return nullptr;
+
+    b.append_base_name (instance.base_name);
+    /* vop<sew>_v --> vop<sew>_v_<type>.  */
+    if (!overloaded_p)
+      {
+	/* vop<sew> --> vop<sew>_v.  */
+	b.append_name (operand_suffixes[instance.op_info->op]);
+	/* vop<sew>_v --> vop<sew>_v_<type>.  */
+	b.append_name (type_suffixes[instance.type.index].vector);
+      }
+
+    /* According to rvv-intrinsic-doc, it does not add "_m" suffix
+       for vop_m C++ overloaded API.  */
+    if (overloaded_p && instance.pred == PRED_TYPE_m)
+      return b.finish_name ();
     b.append_name (predication_suffixes[instance.pred]);
     return b.finish_name ();
   }
@@ -135,5 +188,6 @@ struct loadstore_def : public build_base
 SHAPE(vsetvl, vsetvl)
 SHAPE(vsetvl, vsetvlmax)
 SHAPE(loadstore, loadstore)
+SHAPE(indexed_loadstore, indexed_loadstore)
 
 } // end namespace riscv_vector
diff --git a/gcc/config/riscv/riscv-vector-builtins-shapes.h b/gcc/config/riscv/riscv-vector-builtins-shapes.h
index 64276920..05bc68b 100644
--- a/gcc/config/riscv/riscv-vector-builtins-shapes.h
+++ b/gcc/config/riscv/riscv-vector-builtins-shapes.h
@@ -27,6 +27,7 @@ namespace shapes {
 extern const function_shape *const vsetvl;
 extern const function_shape *const vsetvlmax;
 extern const function_shape *const loadstore;
+extern const function_shape *const indexed_loadstore;
 }
 
 } // end namespace riscv_vector
diff --git a/gcc/config/riscv/riscv-vector-builtins-types.def b/gcc/config/riscv/riscv-vector-builtins-types.def
index 97d5713..a95fad0 100644
--- a/gcc/config/riscv/riscv-vector-builtins-types.def
+++ b/gcc/config/riscv/riscv-vector-builtins-types.def
@@ -36,6 +36,12 @@ along with GCC; see the file COPYING3. If not see
 #define DEF_RVV_F_OPS(TYPE, REQUIRE)
 #endif
 
+/* Use "DEF_RVV_B_OPS" macro include all bool value which will be
+   iterated and registered as intrinsic functions.  */
+#ifndef DEF_RVV_B_OPS
+#define DEF_RVV_B_OPS(TYPE, REQUIRE)
+#endif
+
 DEF_RVV_I_OPS (vint8mf8_t, RVV_REQUIRE_ZVE64)
 DEF_RVV_I_OPS (vint8mf4_t, 0)
 DEF_RVV_I_OPS (vint8mf2_t, 0)
@@ -92,6 +98,15 @@ DEF_RVV_F_OPS (vfloat64m2_t, RVV_REQUIRE_ELEN_FP_64)
 DEF_RVV_F_OPS (vfloat64m4_t, RVV_REQUIRE_ELEN_FP_64)
 DEF_RVV_F_OPS (vfloat64m8_t, RVV_REQUIRE_ELEN_FP_64)
 
+DEF_RVV_B_OPS (vbool64_t, RVV_REQUIRE_ZVE64)
+DEF_RVV_B_OPS (vbool32_t, 0)
+DEF_RVV_B_OPS (vbool16_t, 0)
+DEF_RVV_B_OPS (vbool8_t, 0)
+DEF_RVV_B_OPS (vbool4_t, 0)
+DEF_RVV_B_OPS (vbool2_t, 0)
+DEF_RVV_B_OPS (vbool1_t, 0)
+
 #undef DEF_RVV_I_OPS
 #undef DEF_RVV_U_OPS
 #undef DEF_RVV_F_OPS
+#undef DEF_RVV_B_OPS
diff --git a/gcc/config/riscv/riscv-vector-builtins.cc b/gcc/config/riscv/riscv-vector-builtins.cc
index 59d4f2d..df4e2ee 100644
--- a/gcc/config/riscv/riscv-vector-builtins.cc
+++ b/gcc/config/riscv/riscv-vector-builtins.cc
@@ -141,6 +141,12 @@ static const rvv_type_info all_ops[] = {
 #include "riscv-vector-builtins-types.def"
   {NUM_VECTOR_TYPES, 0}};
 
+/* A list of all bool will be registered for intrinsic functions.  */
+static const rvv_type_info b_ops[] = {
+#define DEF_RVV_B_OPS(TYPE, REQUIRE) {VECTOR_TYPE_##TYPE, REQUIRE},
+#include "riscv-vector-builtins-types.def"
+  {NUM_VECTOR_TYPES, 0}};
+
 static CONSTEXPR const rvv_arg_type_info rvv_arg_type_info_end
   = rvv_arg_type_info (NUM_BASE_TYPES);
 
@@ -158,7 +164,72 @@ static CONSTEXPR const rvv_arg_type_info scalar_const_ptr_args[]
 
 /* A list of args for void func (scalar_type *, vector_type) function.  */
 static CONSTEXPR const rvv_arg_type_info scalar_ptr_args[]
+  = {rvv_arg_type_info (RVV_BASE_scalar_ptr),
+     rvv_arg_type_info (RVV_BASE_vector), rvv_arg_type_info_end};
+
+/* A list of args for vector_type func (const scalar_type *, ptrdiff_t)
+ * function.  */
+static CONSTEXPR const rvv_arg_type_info scalar_const_ptr_ptrdiff_args[]
   = {rvv_arg_type_info (RVV_BASE_scalar_const_ptr),
+     rvv_arg_type_info (RVV_BASE_ptrdiff), rvv_arg_type_info_end};
+
+/* A list of args for void func (scalar_type *, ptrdiff_t, vector_type)
+ * function.  */
+static CONSTEXPR const rvv_arg_type_info scalar_ptr_ptrdiff_args[]
+  = {rvv_arg_type_info (RVV_BASE_scalar_ptr),
+     rvv_arg_type_info (RVV_BASE_ptrdiff), rvv_arg_type_info (RVV_BASE_vector),
+     rvv_arg_type_info_end};
+
+/* A list of args for vector_type func (const scalar_type *, uint8_index_type)
+ * function.  */
+static CONSTEXPR const rvv_arg_type_info scalar_const_ptr_uint8_index_args[]
+  = {rvv_arg_type_info (RVV_BASE_scalar_const_ptr),
+     rvv_arg_type_info (RVV_BASE_uint8_index), rvv_arg_type_info_end};
+
+/* A list of args for vector_type func (const scalar_type *, uint16_index_type)
+ * function.  */
+static CONSTEXPR const rvv_arg_type_info scalar_const_ptr_uint16_index_args[]
+  = {rvv_arg_type_info (RVV_BASE_scalar_const_ptr),
+     rvv_arg_type_info (RVV_BASE_uint16_index), rvv_arg_type_info_end};
+
+/* A list of args for vector_type func (const scalar_type *, uint32_index_type)
+ * function.  */
+static CONSTEXPR const rvv_arg_type_info scalar_const_ptr_uint32_index_args[]
+  = {rvv_arg_type_info (RVV_BASE_scalar_const_ptr),
+     rvv_arg_type_info (RVV_BASE_uint32_index), rvv_arg_type_info_end};
+
+/* A list of args for vector_type func (const scalar_type *, uint64_index_type)
+ * function.  */
+static CONSTEXPR const rvv_arg_type_info scalar_const_ptr_uint64_index_args[]
+  = {rvv_arg_type_info (RVV_BASE_scalar_const_ptr),
+     rvv_arg_type_info (RVV_BASE_uint64_index), rvv_arg_type_info_end};
+
+/* A list of args for void func (scalar_type *, uint8_index_type, vector_type)
+ * function.  */
+static CONSTEXPR const rvv_arg_type_info scalar_ptr_uint8_index_args[]
+  = {rvv_arg_type_info (RVV_BASE_scalar_ptr),
+     rvv_arg_type_info (RVV_BASE_uint8_index),
+     rvv_arg_type_info (RVV_BASE_vector), rvv_arg_type_info_end};
+
+/* A list of args for void func (scalar_type *, uint16_index_type, vector_type)
+ * function.  */
+static CONSTEXPR const rvv_arg_type_info scalar_ptr_uint16_index_args[]
+  = {rvv_arg_type_info (RVV_BASE_scalar_ptr),
+     rvv_arg_type_info (RVV_BASE_uint16_index),
+     rvv_arg_type_info (RVV_BASE_vector), rvv_arg_type_info_end};
+
+/* A list of args for void func (scalar_type *, uint32_index_type, vector_type)
+ * function.  */
+static CONSTEXPR const rvv_arg_type_info scalar_ptr_uint32_index_args[]
+  = {rvv_arg_type_info (RVV_BASE_scalar_ptr),
+     rvv_arg_type_info (RVV_BASE_uint32_index),
+     rvv_arg_type_info (RVV_BASE_vector), rvv_arg_type_info_end};
+
+/* A list of args for void func (scalar_type *, uint64_index_type, vector_type)
+ * function.  */
+static CONSTEXPR const rvv_arg_type_info scalar_ptr_uint64_index_args[]
+  = {rvv_arg_type_info (RVV_BASE_scalar_ptr),
+     rvv_arg_type_info (RVV_BASE_uint64_index),
      rvv_arg_type_info (RVV_BASE_vector), rvv_arg_type_info_end};
 
 /* A list of none preds that will be registered for intrinsic functions.  */
@@ -205,6 +276,102 @@ static CONSTEXPR const rvv_op_info all_v_scalar_ptr_ops
      rvv_arg_type_info (RVV_BASE_void), /* Return type */
      scalar_ptr_args /* Args */};
 
+/* A static operand information for vector_type func (const scalar_type *)
+ * function registration. */
+static CONSTEXPR const rvv_op_info b_v_scalar_const_ptr_ops
+  = {b_ops,				  /* Types */
+     OP_TYPE_v,				  /* Suffix */
+     rvv_arg_type_info (RVV_BASE_vector), /* Return type */
+     scalar_const_ptr_args /* Args */};
+
+/* A static operand information for void func (scalar_type *, vector_type)
+ * function registration. */
+static CONSTEXPR const rvv_op_info b_v_scalar_ptr_ops
+  = {b_ops,				/* Types */
+     OP_TYPE_v,				/* Suffix */
+     rvv_arg_type_info (RVV_BASE_void), /* Return type */
+     scalar_ptr_args /* Args */};
+
+/* A static operand information for vector_type func (const scalar_type *,
+ * ptrdiff_t) function registration. */
+static CONSTEXPR const rvv_op_info all_v_scalar_const_ptr_ptrdiff_ops
+  = {all_ops,				  /* Types */
+     OP_TYPE_v,				  /* Suffix */
+     rvv_arg_type_info (RVV_BASE_vector), /* Return type */
+     scalar_const_ptr_ptrdiff_args /* Args */};
+
+/* A static operand information for vector_type func (const scalar_type *,
+ * uint8_index_type) function registration. */
+static CONSTEXPR const rvv_op_info all_v_scalar_const_ptr_uint8_index_ops
+  = {all_ops,				  /* Types */
+     OP_TYPE_v,				  /* Suffix */
+     rvv_arg_type_info (RVV_BASE_vector), /* Return type */
+     scalar_const_ptr_uint8_index_args /* Args */};
+
+/* A static operand information for vector_type func (const scalar_type *,
+ * uint16_index_type) function registration. */
+static CONSTEXPR const rvv_op_info all_v_scalar_const_ptr_uint16_index_ops
+  = {all_ops,				  /* Types */
+     OP_TYPE_v,				  /* Suffix */
+     rvv_arg_type_info (RVV_BASE_vector), /* Return type */
+     scalar_const_ptr_uint16_index_args /* Args */};
+
+/* A static operand information for vector_type func (const scalar_type *,
+ * uint32_index_type) function registration. */
+static CONSTEXPR const rvv_op_info all_v_scalar_const_ptr_uint32_index_ops
+  = {all_ops,				  /* Types */
+     OP_TYPE_v,				  /* Suffix */
+     rvv_arg_type_info (RVV_BASE_vector), /* Return type */
+     scalar_const_ptr_uint32_index_args /* Args */};
+
+/* A static operand information for vector_type func (const scalar_type *,
+ * uint64_index_type) function registration. */
+static CONSTEXPR const rvv_op_info all_v_scalar_const_ptr_uint64_index_ops
+  = {all_ops,				  /* Types */
+     OP_TYPE_v,				  /* Suffix */
+     rvv_arg_type_info (RVV_BASE_vector), /* Return type */
+     scalar_const_ptr_uint64_index_args /* Args */};
+
+/* A static operand information for void func (scalar_type *, ptrdiff_t,
+ * vector_type) function registration. */
+static CONSTEXPR const rvv_op_info all_v_scalar_ptr_ptrdiff_ops
+  = {all_ops,				/* Types */
+     OP_TYPE_v,				/* Suffix */
+     rvv_arg_type_info (RVV_BASE_void), /* Return type */
+     scalar_ptr_ptrdiff_args /* Args */};
+
+/* A static operand information for void func (scalar_type *, uint8_index_type,
+ * vector_type) function registration. */
+static CONSTEXPR const rvv_op_info all_v_scalar_ptr_uint8_index_ops
+  = {all_ops,				/* Types */
+     OP_TYPE_v,				/* Suffix */
+     rvv_arg_type_info (RVV_BASE_void), /* Return type */
+     scalar_ptr_uint8_index_args /* Args */};
+
+/* A static operand information for void func (scalar_type *, uint16_index_type,
+ * vector_type) function registration. */
+static CONSTEXPR const rvv_op_info all_v_scalar_ptr_uint16_index_ops
+  = {all_ops,				/* Types */
+     OP_TYPE_v,				/* Suffix */
+     rvv_arg_type_info (RVV_BASE_void), /* Return type */
+     scalar_ptr_uint16_index_args /* Args */};
+
+/* A static operand information for void func (scalar_type *, uint32_index_type,
+ * vector_type) function registration. */
+static CONSTEXPR const rvv_op_info all_v_scalar_ptr_uint32_index_ops
+  = {all_ops,				/* Types */
+     OP_TYPE_v,				/* Suffix */
+     rvv_arg_type_info (RVV_BASE_void), /* Return type */
+     scalar_ptr_uint32_index_args /* Args */};
+
+/* A static operand information for void func (scalar_type *, uint64_index_type,
+ * vector_type) function registration. */
+static CONSTEXPR const rvv_op_info all_v_scalar_ptr_uint64_index_ops
+  = {all_ops,				/* Types */
+     OP_TYPE_v,				/* Suffix */
+     rvv_arg_type_info (RVV_BASE_void), /* Return type */
+     scalar_ptr_uint64_index_args /* Args */};
+
 /* A list of all RVV intrinsic functions.  */
 static function_group_info function_groups[] = {
 #define DEF_RVV_FUNCTION(NAME, SHAPE, PREDS, OPS_INFO)                         \
@@ -346,14 +513,15 @@ register_builtin_type (vector_type_index type, tree eltype, machine_mode mode)
 static void
 register_builtin_types ()
 {
-  /* int32_t/uint32_t defined as `long`/`unsigned long` in RV32,
-     but intSI_type_node/unsigned_intSI_type_node is
-     `int` and `unsigned int`, so use long_integer_type_node and
-     long_unsigned_type_node here for type consistent.  */
-  tree int32_type_node
-    = TARGET_64BIT ? intSI_type_node : long_integer_type_node;
-  tree unsigned_int32_type_node
-    = TARGET_64BIT ? unsigned_intSI_type_node : long_unsigned_type_node;
+  /* Get type node from get_typenode_from_name to prevent we have different type
+     node define in different target libraries, e.g. int32_t defined as
+     `long` in RV32/newlib-stdint, but `int` for RV32/glibc-stdint.h.
+     NOTE: uint[16|32|64]_type_node already defined in tree.h.  */
+  tree int8_type_node = get_typenode_from_name (INT8_TYPE);
+  tree uint8_type_node = get_typenode_from_name (UINT8_TYPE);
+  tree int16_type_node = get_typenode_from_name (INT16_TYPE);
+  tree int32_type_node = get_typenode_from_name (INT32_TYPE);
+  tree int64_type_node = get_typenode_from_name (INT64_TYPE);
 
   machine_mode mode;
 #define DEF_RVV_TYPE(NAME, NCHARS, ABI_NAME, SCALAR_TYPE, VECTOR_MODE,         \
@@ -392,11 +560,41 @@ register_vector_type (vector_type_index type)
   builtin_types[type].vector_ptr = build_pointer_type (vectype);
 }
 
+/* Return true if the type has required_extensions.  */
+static bool
+required_extensions_p (enum rvv_base_type type)
+{
+  return type == RVV_BASE_vector || type == RVV_BASE_uint8_index
+	 || type == RVV_BASE_uint16_index || type == RVV_BASE_uint32_index
+	 || type == RVV_BASE_uint64_index;
+}
+
 /* Check whether all the RVV_REQUIRE_* values in REQUIRED_EXTENSIONS are
    enabled.  */
 static bool
-check_required_extensions (uint64_t required_extensions)
+check_required_extensions (const function_instance &instance)
 {
+  rvv_type_info type_info = instance.type;
+  uint64_t required_extensions = type_info.required_extensions;
+  const rvv_op_info *op_info = instance.op_info;
+  tree type = builtin_types[type_info.index].vector;
+  for (unsigned i = 0; op_info->args[i].base_type != NUM_BASE_TYPES; ++i)
+    {
+      if (!required_extensions_p (op_info->args[i].base_type))
+	continue;
+
+      enum vector_type_index vector_type
+	= op_info->args[i].get_base_vector_type (type);
+      if (vector_type == NUM_VECTOR_TYPES)
+	continue;
+      required_extensions |= op_info->types[vector_type].required_extensions;
+
+      /* According to RVV ISA, EEW=64 index of indexed loads/stores require
+	 XLEN = 64.  */
+      if (op_info->args[i].base_type == RVV_BASE_uint64_index)
+	required_extensions |= RVV_REQUIRE_RV64BIT;
+    }
+
   uint64_t riscv_isa_flags = 0;
 
   if (TARGET_VECTOR_ELEN_FP_32)
@@ -450,6 +648,56 @@ get_mask_policy_for_pred (enum predication_type_index pred)
   return gen_int_mode (get_prefer_mask_policy (), Pmode);
 }
 
+vector_type_index
+rvv_arg_type_info::get_base_vector_type (tree type) const
+{
+  if (!type)
+    return NUM_VECTOR_TYPES;
+  poly_int64 nunits = GET_MODE_NUNITS (TYPE_MODE (type));
+  machine_mode inner_mode;
+  bool unsigned_p = TYPE_UNSIGNED (type);
+  switch (base_type)
+    {
+    case RVV_BASE_uint8_index:
+      inner_mode = E_QImode;
+      unsigned_p = true;
+      break;
+    case RVV_BASE_uint16_index:
+      inner_mode = E_HImode;
+      unsigned_p = true;
+      break;
+    case RVV_BASE_uint32_index:
+      inner_mode = E_SImode;
+      unsigned_p = true;
+      break;
+    case RVV_BASE_uint64_index:
+      inner_mode = E_DImode;
+      unsigned_p = true;
+      break;
+    default:
+      return NUM_VECTOR_TYPES;
+    }
+
+  opt_machine_mode mode
+    = get_vector_mode (as_a<scalar_mode> (inner_mode), nunits);
+
+  if (!mode.exists ())
+    return NUM_VECTOR_TYPES;
+  for (unsigned int i = 0; i < NUM_VECTOR_TYPES + 1; i++)
+    {
+      tree vector_type = builtin_types[i].vector;
+      if (!vector_type)
+	continue;
+
+      if (TYPE_UNSIGNED (vector_type) != unsigned_p)
+	continue;
+
+      if (TYPE_MODE (vector_type) == mode.require ())
+	return (enum vector_type_index) i;
+    }
+  return NUM_VECTOR_TYPES;
+}
+
 tree
 rvv_arg_type_info::get_tree_type (vector_type_index type_idx) const
 {
@@ -462,9 +710,19 @@ rvv_arg_type_info::get_tree_type (vector_type_index type_idx) const
     case RVV_BASE_vector_ptr:
       return builtin_types[type_idx].vector_ptr;
     case RVV_BASE_scalar_ptr:
-      return builtin_types[type_idx].scalar_ptr;
+      /* According to the latest rvv-intrinsic-doc, it defines vsm.v intrinsic:
+	 __riscv_vsm (uint8_t *base, vbool1_t value, size_t vl).  */
+      if (type_idx >= VECTOR_TYPE_vbool64_t && type_idx <= VECTOR_TYPE_vbool1_t)
+	return builtin_types[VECTOR_TYPE_vuint8mf8_t].scalar_ptr;
+      else
+	return builtin_types[type_idx].scalar_ptr;
     case RVV_BASE_scalar_const_ptr:
-      return builtin_types[type_idx].scalar_const_ptr;
+      /* According to the latest rvv-intrinsic-doc, it defines vlm.v intrinsic:
+	 __riscv_vlm_v_b1 (const uint8_t *base, size_t vl).  */
+      if (type_idx >= VECTOR_TYPE_vbool64_t && type_idx <= VECTOR_TYPE_vbool1_t)
+	return builtin_types[VECTOR_TYPE_vuint8mf8_t].scalar_const_ptr;
+      else
+	return builtin_types[type_idx].scalar_const_ptr;
     case RVV_BASE_void:
       return void_type_node;
     case RVV_BASE_size:
@@ -475,9 +733,20 @@ rvv_arg_type_info::get_tree_type (vector_type_index type_idx) const
       return long_unsigned_type_node;
     case RVV_BASE_long:
       return long_integer_type_node;
+    case RVV_BASE_uint8_index:
+    case RVV_BASE_uint16_index:
+    case RVV_BASE_uint32_index:
+    case RVV_BASE_uint64_index:
+      if (get_base_vector_type (builtin_types[type_idx].vector)
+	  != NUM_VECTOR_TYPES)
+	return builtin_types[get_base_vector_type (
+			       builtin_types[type_idx].vector)].vector;
+      break;
     default:
       gcc_unreachable ();
     }
+  /* Return NULL_TREE if the type we don't want to register.  */
+  return NULL_TREE;
 }
 
 function_instance::function_instance (const char *base_name_in,
@@ -777,7 +1046,7 @@ function_builder::add_unique_function (const function_instance &instance,
 				       vec<tree> &argument_types)
 {
   /* Do not add this function if it is invalid.  */
-  if (!check_required_extensions (instance.type.required_extensions))
+  if (!check_required_extensions (instance))
     return;
 
   /* Add the function under its full (unique) name.  */
@@ -845,15 +1114,53 @@ function_expander::add_vundef_operand (machine_mode mode)
 }
 
 /* Add a memory operand with mode MODE and address ADDR.  */
-rtx
-function_expander::add_mem_operand (machine_mode mode, rtx addr)
+void
+function_expander::add_mem_operand (machine_mode mode, unsigned argno)
 {
   gcc_assert (VECTOR_MODE_P (mode));
+  rtx addr = expand_normal (CALL_EXPR_ARG (exp, argno));
   rtx mem = gen_rtx_MEM (mode, memory_address (mode, addr));
   /* The memory is only guaranteed to be element-aligned.  */
   set_mem_align (mem, GET_MODE_ALIGNMENT (GET_MODE_INNER (mode)));
   add_fixed_operand (mem);
-  return mem;
+}
+
+/* Implement the call using instruction ICODE, with a 1:1 mapping between
+   arguments and input operands.  */
+rtx
+function_expander::use_exact_insn (insn_code icode)
+{
+  machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
+  tree mask_type = builtin_types[mask_types[type.index]].vector;
+  machine_mode mask_mode = TYPE_MODE (mask_type);
+
+  /* Record the offset to get the argument.  */
+  int arg_offset = 0;
+
+  if (use_real_mask_p (pred))
+    add_input_operand (arg_offset++);
+  else
+    add_all_one_mask_operand (mask_mode);
+
+  /* Store operation doesn't have merge operand.  */
+  if (!function_returns_void_p ())
+    {
+      if (use_real_merge_p (pred))
+	add_input_operand (arg_offset++);
+      else
+	add_vundef_operand (mode);
+    }
+
+  for (int argno = arg_offset; argno < call_expr_nargs (exp); argno++)
+    add_input_operand (argno);
+
+  if (base->apply_tail_policy_p ())
+    add_input_operand (Pmode, get_tail_policy_for_pred (pred));
+  if (base->apply_mask_policy_p ())
+    add_input_operand (Pmode, get_mask_policy_for_pred (pred));
+
+  add_input_operand (Pmode, get_avl_type_rtx (avl_type::NONVLMAX));
+  return generate_insn (icode);
 }
 
 /* Use contiguous load INSN.  */
@@ -878,16 +1185,19 @@ function_expander::use_contiguous_load_insn (insn_code icode)
   else
     add_vundef_operand (mode);
 
-  tree addr_arg = CALL_EXPR_ARG (exp, arg_offset++);
-  rtx addr = expand_normal (addr_arg);
-  add_mem_operand (mode, addr);
+  add_mem_operand (mode, arg_offset++);
 
   for (int argno = arg_offset; argno < call_expr_nargs (exp); argno++)
     add_input_operand (argno);
 
-  add_input_operand (Pmode, get_tail_policy_for_pred (pred));
-  add_input_operand (Pmode, get_mask_policy_for_pred (pred));
-  add_input_operand (Pmode, get_avl_type_rtx (avl_type::NONVLMAX));
+  if (GET_MODE_CLASS (mode) != MODE_VECTOR_BOOL)
+    {
+      add_input_operand (Pmode, get_tail_policy_for_pred (pred));
+      add_input_operand (Pmode, get_mask_policy_for_pred (pred));
+    }
+
+  if (opno != insn_data[icode].n_generator_args)
+    add_input_operand (Pmode, get_avl_type_rtx (avl_type::NONVLMAX));
 
   return generate_insn (icode);
 }
@@ -904,27 +1214,17 @@ function_expander::use_contiguous_store_insn (insn_code icode)
   /* Record the offset to get the argument.  */
   int arg_offset = 0;
 
-  int addr_loc = use_real_mask_p (pred) ? 1 : 0;
-  tree addr_arg = CALL_EXPR_ARG (exp, addr_loc);
-  rtx addr = expand_normal (addr_arg);
-  rtx mem = add_mem_operand (mode, addr);
+  add_mem_operand (mode, use_real_mask_p (pred) ? 1 : 0);
 
   if (use_real_mask_p (pred))
     add_input_operand (arg_offset++);
   else
     add_all_one_mask_operand (mask_mode);
 
-  /* To model "+m" constraint, we include memory operand into input.  */
-  add_input_operand (mode, mem);
-
   arg_offset++;
   for (int argno = arg_offset; argno < call_expr_nargs (exp); argno++)
     add_input_operand (argno);
 
-  add_input_operand (Pmode, get_tail_policy_for_pred (pred));
-  add_input_operand (Pmode, get_mask_policy_for_pred (pred));
-  add_input_operand (Pmode, get_avl_type_rtx (avl_type::NONVLMAX));
-
   return generate_insn (icode);
 }
 
diff --git a/gcc/config/riscv/riscv-vector-builtins.def b/gcc/config/riscv/riscv-vector-builtins.def
index 12cb440..89bd5f1 100644
--- a/gcc/config/riscv/riscv-vector-builtins.def
+++ b/gcc/config/riscv/riscv-vector-builtins.def
@@ -89,147 +89,147 @@ DEF_RVV_TYPE (vbool1_t, 13, __rvv_bool1_t, boolean, VNx64BI, VNx32BI, _b1, , , v
 
 /* LMUL = 1/8:
    Only enble when TARGET_MIN_VLEN > 32 and machine mode = VNx1QImode.  */
-DEF_RVV_TYPE (vint8mf8_t, 15, __rvv_int8mf8_t, intQI, VNx1QI, VOID, _i8mf8, _i8,
+DEF_RVV_TYPE (vint8mf8_t, 15, __rvv_int8mf8_t, int8, VNx1QI, VOID, _i8mf8, _i8,
 	      _e8mf8, vbool64_t)
-DEF_RVV_TYPE (vuint8mf8_t, 16, __rvv_uint8mf8_t, unsigned_intQI, VNx1QI, VOID,
+DEF_RVV_TYPE (vuint8mf8_t, 16, __rvv_uint8mf8_t, uint8, VNx1QI, VOID,
 	      _u8mf8, _u8, _e8mf8, vbool64_t)
 /* LMUL = 1/4:
    Machine mode = VNx2QImode when TARGET_MIN_VLEN > 32.
    Machine mode = VNx1QImode when TARGET_MIN_VLEN = 32.  */
-DEF_RVV_TYPE (vint8mf4_t, 15, __rvv_int8mf4_t, intQI, VNx2QI, VNx1QI, _i8mf4,
+DEF_RVV_TYPE (vint8mf4_t, 15, __rvv_int8mf4_t, int8, VNx2QI, VNx1QI, _i8mf4,
 	      _i8, _e8mf4, vbool32_t)
-DEF_RVV_TYPE (vuint8mf4_t, 16, __rvv_uint8mf4_t, unsigned_intQI, VNx2QI, VNx1QI,
+DEF_RVV_TYPE (vuint8mf4_t, 16, __rvv_uint8mf4_t, uint8, VNx2QI, VNx1QI,
 	      _u8mf4, _u8, _e8mf4, vbool32_t)
 /* LMUL = 1/2:
    Machine mode = VNx4QImode when TARGET_MIN_VLEN > 32.
    Machine mode = VNx2QImode when TARGET_MIN_VLEN = 32.  */
-DEF_RVV_TYPE (vint8mf2_t, 15, __rvv_int8mf2_t, intQI, VNx4QI, VNx2QI, _i8mf2,
+DEF_RVV_TYPE (vint8mf2_t, 15, __rvv_int8mf2_t, int8, VNx4QI, VNx2QI, _i8mf2,
 	      _i8, _e8mf2, vbool16_t)
-DEF_RVV_TYPE (vuint8mf2_t, 16, __rvv_uint8mf2_t, unsigned_intQI, VNx4QI, VNx2QI,
+DEF_RVV_TYPE (vuint8mf2_t, 16, __rvv_uint8mf2_t, uint8, VNx4QI, VNx2QI,
 	      _u8mf2, _u8, _e8mf2, vbool16_t)
 /* LMUL = 1:
    Machine mode = VNx8QImode when TARGET_MIN_VLEN > 32.
    Machine mode = VNx4QImode when TARGET_MIN_VLEN = 32.  */
-DEF_RVV_TYPE (vint8m1_t, 14, __rvv_int8m1_t, intQI, VNx8QI, VNx4QI, _i8m1, _i8,
+DEF_RVV_TYPE (vint8m1_t, 14, __rvv_int8m1_t, int8, VNx8QI, VNx4QI, _i8m1, _i8,
 	      _e8m1, vbool8_t)
-DEF_RVV_TYPE (vuint8m1_t, 15, __rvv_uint8m1_t, unsigned_intQI, VNx8QI, VNx4QI,
+DEF_RVV_TYPE (vuint8m1_t, 15, __rvv_uint8m1_t, uint8, VNx8QI, VNx4QI,
 	      _u8m1, _u8, _e8m1, vbool8_t)
 /* LMUL = 2:
    Machine mode = VNx16QImode when TARGET_MIN_VLEN > 32.
    Machine mode = VNx8QImode when TARGET_MIN_VLEN = 32.  */
-DEF_RVV_TYPE (vint8m2_t, 14, __rvv_int8m2_t, intQI, VNx16QI, VNx8QI, _i8m2, _i8,
+DEF_RVV_TYPE (vint8m2_t, 14, __rvv_int8m2_t, int8, VNx16QI, VNx8QI, _i8m2, _i8,
 	      _e8m2, vbool4_t)
-DEF_RVV_TYPE (vuint8m2_t, 15, __rvv_uint8m2_t, unsigned_intQI, VNx16QI, VNx8QI,
+DEF_RVV_TYPE (vuint8m2_t, 15, __rvv_uint8m2_t, uint8, VNx16QI, VNx8QI,
 	      _u8m2, _u8, _e8m2, vbool4_t)
 /* LMUL = 4:
    Machine mode = VNx32QImode when TARGET_MIN_VLEN > 32.
    Machine mode = VNx16QImode when TARGET_MIN_VLEN = 32.  */
-DEF_RVV_TYPE (vint8m4_t, 14, __rvv_int8m4_t, intQI, VNx32QI, VNx16QI, _i8m4,
+DEF_RVV_TYPE (vint8m4_t, 14, __rvv_int8m4_t, int8, VNx32QI, VNx16QI, _i8m4,
 	      _i8, _e8m4, vbool2_t)
-DEF_RVV_TYPE (vuint8m4_t, 15, __rvv_uint8m4_t, unsigned_intQI, VNx32QI, VNx16QI,
+DEF_RVV_TYPE (vuint8m4_t, 15, __rvv_uint8m4_t, uint8, VNx32QI, VNx16QI,
 	      _u8m4, _u8, _e8m4, vbool2_t)
 /* LMUL = 8:
    Machine mode = VNx64QImode when TARGET_MIN_VLEN > 32.
    Machine mode = VNx32QImode when TARGET_MIN_VLEN = 32.  */
-DEF_RVV_TYPE (vint8m8_t, 14, __rvv_int8m8_t, intQI, VNx64QI, VNx32QI, _i8m8,
+DEF_RVV_TYPE (vint8m8_t, 14, __rvv_int8m8_t, int8, VNx64QI, VNx32QI, _i8m8,
 	      _i8, _e8m8, vbool1_t)
-DEF_RVV_TYPE (vuint8m8_t, 15, __rvv_uint8m8_t, unsigned_intQI, VNx64QI, VNx32QI,
+DEF_RVV_TYPE (vuint8m8_t, 15, __rvv_uint8m8_t, uint8, VNx64QI, VNx32QI,
 	      _u8m8, _u8, _e8m8, vbool1_t)
 
 /* LMUL = 1/4:
    Only enble when TARGET_MIN_VLEN > 32 and machine mode = VNx1HImode.  */
-DEF_RVV_TYPE (vint16mf4_t, 16, __rvv_int16mf4_t, intHI, VNx1HI, VOID, _i16mf4,
+DEF_RVV_TYPE (vint16mf4_t, 16, __rvv_int16mf4_t, int16, VNx1HI, VOID, _i16mf4,
 	      _i16, _e16mf4, vbool64_t)
-DEF_RVV_TYPE (vuint16mf4_t, 17, __rvv_uint16mf4_t, unsigned_intHI, VNx1HI, VOID,
+DEF_RVV_TYPE (vuint16mf4_t, 17, __rvv_uint16mf4_t, uint16, VNx1HI, VOID,
 	      _u16mf4, _u16, _e16mf4, vbool64_t)
 /* LMUL = 1/2:
    Machine mode = VNx2HImode when TARGET_MIN_VLEN > 32.
    Machine mode = VNx1HImode when TARGET_MIN_VLEN = 32.  */
-DEF_RVV_TYPE (vint16mf2_t, 16, __rvv_int16mf2_t, intHI, VNx2HI, VNx1HI, _i16mf2,
+DEF_RVV_TYPE (vint16mf2_t, 16, __rvv_int16mf2_t, int16, VNx2HI, VNx1HI, _i16mf2,
 	      _i16, _e16mf2, vbool32_t)
-DEF_RVV_TYPE (vuint16mf2_t, 17, __rvv_uint16mf2_t, unsigned_intHI, VNx2HI,
+DEF_RVV_TYPE (vuint16mf2_t, 17, __rvv_uint16mf2_t, uint16, VNx2HI,
 	      VNx1HI, _u16mf2, _u16, _e16mf2, vbool32_t)
 /* LMUL = 1:
    Machine mode = VNx4HImode when TARGET_MIN_VLEN > 32.
    Machine mode = VNx2HImode when TARGET_MIN_VLEN = 32.  */
-DEF_RVV_TYPE (vint16m1_t, 15, __rvv_int16m1_t, intHI, VNx4HI, VNx2HI, _i16m1,
+DEF_RVV_TYPE (vint16m1_t, 15, __rvv_int16m1_t, int16, VNx4HI, VNx2HI, _i16m1,
 	      _i16, _e16m1, vbool16_t)
-DEF_RVV_TYPE (vuint16m1_t, 16, __rvv_uint16m1_t, unsigned_intHI, VNx4HI, VNx2HI,
+DEF_RVV_TYPE (vuint16m1_t, 16, __rvv_uint16m1_t, uint16, VNx4HI, VNx2HI,
 	      _u16m1, _u16, _e16m1, vbool16_t)
 /* LMUL = 2:
    Machine mode = VNx8HImode when TARGET_MIN_VLEN > 32.
    Machine mode = VNx4HImode when TARGET_MIN_VLEN = 32.  */
-DEF_RVV_TYPE (vint16m2_t, 15, __rvv_int16m2_t, intHI, VNx8HI, VNx4HI, _i16m2,
+DEF_RVV_TYPE (vint16m2_t, 15, __rvv_int16m2_t, int16, VNx8HI, VNx4HI, _i16m2,
 	      _i16, _e16m2, vbool8_t)
-DEF_RVV_TYPE (vuint16m2_t, 16, __rvv_uint16m2_t, unsigned_intHI, VNx8HI, VNx4HI,
+DEF_RVV_TYPE (vuint16m2_t, 16, __rvv_uint16m2_t, uint16, VNx8HI, VNx4HI,
 	      _u16m2, _u16, _e16m2, vbool8_t)
 /* LMUL = 4:
    Machine mode = VNx16HImode when TARGET_MIN_VLEN > 32.
    Machine mode = VNx8HImode when TARGET_MIN_VLEN = 32.  */
-DEF_RVV_TYPE (vint16m4_t, 15, __rvv_int16m4_t, intHI, VNx16HI, VNx8HI, _i16m4,
+DEF_RVV_TYPE (vint16m4_t, 15, __rvv_int16m4_t, int16, VNx16HI, VNx8HI, _i16m4,
 	      _i16, _e16m4, vbool4_t)
-DEF_RVV_TYPE (vuint16m4_t, 16, __rvv_uint16m4_t, unsigned_intHI, VNx16HI,
+DEF_RVV_TYPE (vuint16m4_t, 16, __rvv_uint16m4_t, uint16, VNx16HI,
 	      VNx8HI, _u16m4, _u16, _e16m4, vbool4_t)
 /* LMUL = 8:
    Machine mode = VNx32HImode when TARGET_MIN_VLEN > 32.
    Machine mode = VNx16HImode when TARGET_MIN_VLEN = 32.  */
-DEF_RVV_TYPE (vint16m8_t, 15, __rvv_int16m8_t, intHI, VNx32HI, VNx16HI, _i16m8,
+DEF_RVV_TYPE (vint16m8_t, 15, __rvv_int16m8_t, int16, VNx32HI, VNx16HI, _i16m8,
 	      _i16, _e16m8, vbool2_t)
-DEF_RVV_TYPE (vuint16m8_t, 16, __rvv_uint16m8_t, unsigned_intHI, VNx32HI,
+DEF_RVV_TYPE (vuint16m8_t, 16, __rvv_uint16m8_t, uint16, VNx32HI,
 	      VNx16HI, _u16m8, _u16, _e16m8, vbool2_t)
 
 /* LMUL = 1/2:
    Only enble when TARGET_MIN_VLEN > 32 and machine mode = VNx1SImode.  */
 DEF_RVV_TYPE (vint32mf2_t, 16, __rvv_int32mf2_t, int32, VNx1SI, VOID, _i32mf2,
 	      _i32, _e32mf2, vbool64_t)
-DEF_RVV_TYPE (vuint32mf2_t, 17, __rvv_uint32mf2_t, unsigned_int32, VNx1SI, VOID,
+DEF_RVV_TYPE (vuint32mf2_t, 17, __rvv_uint32mf2_t, uint32, VNx1SI, VOID,
 	      _u32mf2, _u32, _e32mf2, vbool64_t)
 /* LMUL = 1:
    Machine mode = VNx2SImode when TARGET_MIN_VLEN > 32.
    Machine mode = VNx1SImode when TARGET_MIN_VLEN = 32.  */
 DEF_RVV_TYPE (vint32m1_t, 15, __rvv_int32m1_t, int32, VNx2SI, VNx1SI, _i32m1,
 	      _i32, _e32m1, vbool32_t)
-DEF_RVV_TYPE (vuint32m1_t, 16, __rvv_uint32m1_t, unsigned_int32, VNx2SI, VNx1SI,
+DEF_RVV_TYPE (vuint32m1_t, 16, __rvv_uint32m1_t, uint32, VNx2SI, VNx1SI,
 	      _u32m1, _u32, _e32m1, vbool32_t)
 /* LMUL = 2:
    Machine mode = VNx4SImode when TARGET_MIN_VLEN > 32.
    Machine mode = VNx2SImode when TARGET_MIN_VLEN = 32.  */
 DEF_RVV_TYPE (vint32m2_t, 15, __rvv_int32m2_t, int32, VNx4SI, VNx2SI, _i32m2,
 	      _i32, _e32m2, vbool16_t)
-DEF_RVV_TYPE (vuint32m2_t, 16, __rvv_uint32m2_t, unsigned_int32, VNx4SI, VNx2SI,
+DEF_RVV_TYPE (vuint32m2_t, 16, __rvv_uint32m2_t, uint32, VNx4SI, VNx2SI,
 	      _u32m2, _u32, _e32m2, vbool16_t)
 /* LMUL = 4:
    Machine mode = VNx8SImode when TARGET_MIN_VLEN > 32.
    Machine mode = VNx4SImode when TARGET_MIN_VLEN = 32.  */
 DEF_RVV_TYPE (vint32m4_t, 15, __rvv_int32m4_t, int32, VNx8SI, VNx4SI, _i32m4,
 	      _i32, _e32m4, vbool8_t)
-DEF_RVV_TYPE (vuint32m4_t, 16, __rvv_uint32m4_t, unsigned_int32, VNx8SI, VNx4SI,
+DEF_RVV_TYPE (vuint32m4_t, 16, __rvv_uint32m4_t, uint32, VNx8SI, VNx4SI,
 	      _u32m4, _u32, _e32m4, vbool8_t)
 /* LMUL = 8:
    Machine mode = VNx16SImode when TARGET_MIN_VLEN > 32.
    Machine mode = VNx8SImode when TARGET_MIN_VLEN = 32.  */
 DEF_RVV_TYPE (vint32m8_t, 15, __rvv_int32m8_t, int32, VNx16SI, VNx8SI, _i32m8,
 	      _i32, _e32m8, vbool4_t)
-DEF_RVV_TYPE (vuint32m8_t, 16, __rvv_uint32m8_t, unsigned_int32, VNx16SI,
+DEF_RVV_TYPE (vuint32m8_t, 16, __rvv_uint32m8_t, uint32, VNx16SI,
 	      VNx8SI, _u32m8, _u32, _e32m8, vbool4_t)
 
 /* SEW = 64:
    Disable when TARGET_MIN_VLEN > 32.  */
-DEF_RVV_TYPE (vint64m1_t, 15, __rvv_int64m1_t, intDI, VNx1DI, VOID, _i64m1,
+DEF_RVV_TYPE (vint64m1_t, 15, __rvv_int64m1_t, int64, VNx1DI, VOID, _i64m1,
 	      _i64, _e64m1, vbool64_t)
-DEF_RVV_TYPE (vuint64m1_t, 16, __rvv_uint64m1_t, unsigned_intDI, VNx1DI, VOID,
+DEF_RVV_TYPE (vuint64m1_t, 16, __rvv_uint64m1_t, uint64, VNx1DI, VOID,
 	      _u64m1, _u64, _e64m1, vbool64_t)
-DEF_RVV_TYPE (vint64m2_t, 15, __rvv_int64m2_t, intDI, VNx2DI, VOID, _i64m2,
+DEF_RVV_TYPE (vint64m2_t, 15, __rvv_int64m2_t, int64, VNx2DI, VOID, _i64m2,
 	      _i64, _e64m2, vbool32_t)
-DEF_RVV_TYPE (vuint64m2_t, 16, __rvv_uint64m2_t, unsigned_intDI, VNx2DI, VOID,
+DEF_RVV_TYPE (vuint64m2_t, 16, __rvv_uint64m2_t, uint64, VNx2DI, VOID,
 	      _u64m2, _u64, _e64m2, vbool32_t)
-DEF_RVV_TYPE (vint64m4_t, 15, __rvv_int64m4_t, intDI, VNx4DI, VOID, _i64m4,
+DEF_RVV_TYPE (vint64m4_t, 15, __rvv_int64m4_t, int64, VNx4DI, VOID, _i64m4,
 	      _i64, _e64m4, vbool16_t)
-DEF_RVV_TYPE (vuint64m4_t, 16, __rvv_uint64m4_t, unsigned_intDI, VNx4DI, VOID,
+DEF_RVV_TYPE (vuint64m4_t, 16, __rvv_uint64m4_t, uint64, VNx4DI, VOID,
 	      _u64m4, _u64, _e64m4, vbool16_t)
-DEF_RVV_TYPE (vint64m8_t, 15, __rvv_int64m8_t, intDI, VNx8DI, VOID, _i64m8,
+DEF_RVV_TYPE (vint64m8_t, 15, __rvv_int64m8_t, int64, VNx8DI, VOID, _i64m8,
 	      _i64, _e64m8, vbool8_t)
-DEF_RVV_TYPE (vuint64m8_t, 16, __rvv_uint64m8_t, unsigned_intDI, VNx8DI, VOID,
+DEF_RVV_TYPE (vuint64m8_t, 16, __rvv_uint64m8_t, uint64, VNx8DI, VOID,
 	      _u64m8, _u64, _e64m8, vbool8_t)
 
 /* LMUL = 1/2:
diff --git a/gcc/config/riscv/riscv-vector-builtins.h b/gcc/config/riscv/riscv-vector-builtins.h
index bd33095..aec66b8 100644
--- a/gcc/config/riscv/riscv-vector-builtins.h
+++ b/gcc/config/riscv/riscv-vector-builtins.h
@@ -147,6 +147,10 @@ enum rvv_base_type
   RVV_BASE_ptrdiff,
   RVV_BASE_unsigned_long,
   RVV_BASE_long,
+  RVV_BASE_uint8_index,
+  RVV_BASE_uint16_index,
+  RVV_BASE_uint32_index,
+  RVV_BASE_uint64_index,
   NUM_BASE_TYPES
 };
 
@@ -176,6 +180,7 @@ struct rvv_arg_type_info
   {}
   enum rvv_base_type base_type;
 
+  vector_type_index get_base_vector_type (tree type) const;
   tree get_tree_type (vector_type_index) const;
 };
 
@@ -317,15 +322,17 @@ public:
   rtx expand ();
 
   void add_input_operand (machine_mode, rtx);
-  void add_input_operand (unsigned argno);
+  void add_input_operand (unsigned);
   void add_output_operand (machine_mode, rtx);
-  void add_all_one_mask_operand (machine_mode mode);
-  void add_vundef_operand (machine_mode mode);
+  void add_all_one_mask_operand (machine_mode);
+  void add_vundef_operand (machine_mode);
   void add_fixed_operand (rtx);
-  rtx add_mem_operand (machine_mode, rtx);
+  void add_mem_operand (machine_mode, unsigned);
 
   machine_mode vector_mode (void) const;
+  machine_mode index_mode (void) const;
 
+  rtx use_exact_insn (insn_code);
   rtx use_contiguous_load_insn (insn_code);
   rtx use_contiguous_store_insn (insn_code);
   rtx generate_insn (insn_code);
@@ -358,6 +365,12 @@ public:
   /* Return true if intrinsics should apply vl operand.  */
   virtual bool apply_vl_p () const;
 
+  /* Return true if intrinsics should apply tail policy operand.  */
+  virtual bool apply_tail_policy_p () const;
+
+  /* Return true if intrinsics should apply mask policy operand.  */
+  virtual bool apply_mask_policy_p () const;
+
   /* Return true if intrinsic can be overloaded.  */
   virtual bool can_be_overloaded_p (enum predication_type_index) const;
 
@@ -444,6 +457,13 @@ function_expander::vector_mode (void) const
   return TYPE_MODE (builtin_types[type.index].vector);
 }
 
+/* Return the machine_mode of the corresponding index type.  */
+inline machine_mode
+function_expander::index_mode (void) const
+{
+  return TYPE_MODE (op_info->args[1].get_tree_type (type.index));
+}
+
 /* Default implementation of function_base::call_properties, with conservatively
    correct behavior for floating-point instructions.  */
 inline unsigned int
@@ -463,6 +483,22 @@ function_base::apply_vl_p () const
   return true;
 }
 
+/* We choose to apply tail policy operand by default since most of the
+   intrinsics has tail policy operand.  */
+inline bool
+function_base::apply_tail_policy_p () const
+{
+  return true;
+}
+
+/* We choose to apply mask policy operand by default since most of the
+   intrinsics has mask policy operand.  */
+inline bool
+function_base::apply_mask_policy_p () const
+{
+  return true;
+}
+
 /* Since most of intrinsics can be overloaded, we set it true by default.  */
 inline bool
 function_base::can_be_overloaded_p (enum predication_type_index) const
diff --git a/gcc/config/riscv/riscv-vsetvl.cc b/gcc/config/riscv/riscv-vsetvl.cc
index 0f2cdff..ef5b74c 100644
--- a/gcc/config/riscv/riscv-vsetvl.cc
+++ b/gcc/config/riscv/riscv-vsetvl.cc
@@ -43,7 +43,8 @@ along with GCC; see the file COPYING3.  If not see
     -  Phase 2 - Emit vsetvl instructions within each basic block according to
        demand, compute and save ANTLOC && AVLOC of each block.
 
-    -  Phase 3 - Backward demanded info propagation and fusion across blocks.
+    -  Phase 3 - Backward && forward demanded info propagation and fusion across
+       blocks.
 
     -  Phase 4 - Lazy code motion including: compute local properties,
        pre_edge_lcm and vsetvl insertion && delete edges for LCM results.
@@ -52,6 +53,8 @@ along with GCC; see the file COPYING3.  If not see
        used any more and VL operand of VSETVL instruction if it is not used by
        any non-debug instructions.
 
+    -  Phase 6 - Propagate AVL between vsetvl instructions.
+
     Implementation:
 
     -  The subroutine of optimize == 0 is simple_vsetvl.
@@ -116,10 +119,27 @@ vlmax_avl_insn_p (rtx_insn *rinsn)
 	  || INSN_CODE (rinsn) == CODE_FOR_vlmax_avldi);
 }
 
+/* Return true if the block is a loop itself:
+	  local_dem
+	     __________
+	 ____|____     |
+	|        |     |
+	|________|     |
+	     |_________|
+	  reaching_out
+*/
 static bool
 loop_basic_block_p (const basic_block cfg_bb)
 {
-  return JUMP_P (BB_END (cfg_bb)) && any_condjump_p (BB_END (cfg_bb));
+  if (JUMP_P (BB_END (cfg_bb)) && any_condjump_p (BB_END (cfg_bb)))
+    {
+      edge e;
+      edge_iterator ei;
+      FOR_EACH_EDGE (e, ei, cfg_bb->succs)
+	if (e->dest->index == cfg_bb->index)
+	  return true;
+    }
+  return false;
 }
 
 /* Return true if it is an RVV instruction depends on VTYPE global
@@ -156,38 +176,116 @@ vector_config_insn_p (rtx_insn *rinsn)
 static bool
 vsetvl_insn_p (rtx_insn *rinsn)
 {
+  if (!vector_config_insn_p (rinsn))
+    return false;
   return (INSN_CODE (rinsn) == CODE_FOR_vsetvldi
-	 || INSN_CODE (rinsn) == CODE_FOR_vsetvlsi);
+	  || INSN_CODE (rinsn) == CODE_FOR_vsetvlsi);
 }
 
-/* Return true if INSN1 comes befeore INSN2 in the same block.  */
+/* Return true if it is vsetvl zero, rs1.  */
 static bool
-same_bb_and_before_p (const insn_info *insn1, const insn_info *insn2)
+vsetvl_discard_result_insn_p (rtx_insn *rinsn)
 {
-  return ((insn1->bb ()->index () == insn2->bb ()->index ())
-	 && (*insn1 < *insn2));
+  if (!vector_config_insn_p (rinsn))
+    return false;
+  return (INSN_CODE (rinsn) == CODE_FOR_vsetvl_discard_resultdi
+	  || INSN_CODE (rinsn) == CODE_FOR_vsetvl_discard_resultsi);
+}
+
+static bool
+real_insn_and_same_bb_p (const insn_info *insn, const bb_info *bb)
+{
+  return insn != nullptr && insn->is_real () && insn->bb () == bb;
 }
 
-/* Return true if INSN1 comes after or equal INSN2 in the same block.  */
 static bool
-same_bb_and_after_or_equal_p (const insn_info *insn1, const insn_info *insn2)
+before_p (const insn_info *insn1, const insn_info *insn2)
+{
+  return insn1->compare_with (insn2) < 0;
+}
+
+static insn_info *
+find_reg_killed_by (const bb_info *bb, rtx x)
+{
+  if (!x || vlmax_avl_p (x) || !REG_P (x))
+    return nullptr;
+  for (insn_info *insn : bb->reverse_real_nondebug_insns ())
+    if (find_access (insn->defs (), REGNO (x)))
+      return insn;
+  return nullptr;
+}
+
+/* Helper function to get VL operand.  */
+static rtx
+get_vl (rtx_insn *rinsn)
 {
-  return ((insn1->bb ()->index () == insn2->bb ()->index ())
-	 && (*insn1 >= *insn2));
+  if (has_vl_op (rinsn))
+    {
+      extract_insn_cached (rinsn);
+      return recog_data.operand[get_attr_vl_op_idx (rinsn)];
+    }
+  return SET_DEST (XVECEXP (PATTERN (rinsn), 0, 0));
+}
+
+static bool
+has_vsetvl_killed_avl_p (const bb_info *bb, const vector_insn_info &info)
+{
+  if (info.dirty_with_killed_avl_p ())
+    {
+      rtx avl = info.get_avl ();
+      if (vlmax_avl_p (avl))
+	return find_reg_killed_by (bb, get_vl (info.get_insn ()->rtl ()))
+	       != nullptr;
+      for (const insn_info *insn : bb->reverse_real_nondebug_insns ())
+	{
+	  def_info *def = find_access (insn->defs (), REGNO (avl));
+	  if (def)
+	    {
+	      set_info *set = safe_dyn_cast<set_info *> (def);
+	      if (!set)
+		return false;
+
+	      rtx new_avl = gen_rtx_REG (GET_MODE (avl), REGNO (avl));
+	      gcc_assert (new_avl != avl);
+	      if (!info.compatible_avl_p (avl_info (new_avl, set)))
+		return false;
+
+	      return true;
+	    }
+	}
+    }
+  return false;
 }
 
 /* An "anticipatable occurrence" is one that is the first occurrence in the
    basic block, the operands are not modified in the basic block prior
    to the occurrence and the output is not used between the start of
-   the block and the occurrence.  */
+   the block and the occurrence.
+
+   For VSETVL instruction, we have these following formats:
+     1. vsetvl zero, rs1.
+     2. vsetvl zero, imm.
+     3. vsetvl rd, rs1.
+
+   So base on these circumstances, a DEM is considered as a local anticipatable
+   occurrence should satisfy these following conditions:
+
+     1). rs1 (avl) are not modified in the basic block prior to the VSETVL.
+     2). rd (vl) are not modified in the basic block prior to the VSETVL.
+     3). rd (vl) is not used between the start of the block and the occurrence.
+
+   Note: We don't need to check VL/VTYPE here since DEM is UNKNOWN if VL/VTYPE
+	 is modified prior to the occurrence. This case is already considered as
+	 a non-local anticipatable occurrence.
+*/
 static bool
-anticipatable_occurrence_p (const insn_info *insn, const vector_insn_info dem)
+anticipatable_occurrence_p (const bb_info *bb, const vector_insn_info dem)
 {
+  insn_info *insn = dem.get_insn ();
   /* The only possible operand we care of VSETVL is AVL.  */
   if (dem.has_avl_reg ())
     {
-      /* The operands should not be modified in the basic block prior
-	 to the occurrence.  */
+      /* rs1 (avl) are not modified in the basic block prior to the VSETVL.  */
       if (!vlmax_avl_p (dem.get_avl ()))
 	{
 	  set_info *set
@@ -195,20 +293,27 @@ anticipatable_occurrence_p (const insn_info *insn, const vector_insn_info dem)
 	  /* If it's undefined, it's not anticipatable conservatively.  */
 	  if (!set)
 	    return false;
-	  if (same_bb_and_before_p (set->insn (), insn))
+	  if (real_insn_and_same_bb_p (set->insn (), bb)
+	      && before_p (set->insn (), insn))
 	    return false;
 	}
     }
 
-  /* The output should not be used between the start of the block
-     and the occurrence.  */
+  /* rd (vl) is not used between the start of the block and the occurrence.  */
   if (vsetvl_insn_p (insn->rtl ()))
     {
-      rtx dest = SET_DEST (XVECEXP (PATTERN (insn->rtl ()), 0, 0));
-      for (insn_info *i = insn->prev_nondebug_insn (); i != nullptr;
-	   i = i->prev_nondebug_insn ())
-	if (find_access (i->uses (), REGNO (dest)))
-	  return false;
+      rtx dest = get_vl (insn->rtl ());
+      for (insn_info *i = insn->prev_nondebug_insn ();
+	   real_insn_and_same_bb_p (i, bb); i = i->prev_nondebug_insn ())
+	{
+	  /* rd (vl) is not used between the start of the block and the
+	   * occurrence.  */
+	  if (find_access (i->uses (), REGNO (dest)))
+	    return false;
+	  /* rd (vl) are not modified in the basic block prior to the VSETVL. */
+	  if (find_access (i->defs (), REGNO (dest)))
+	    return false;
+	}
     }
 
   return true;
@@ -216,54 +321,54 @@ anticipatable_occurrence_p (const insn_info *insn, const vector_insn_info dem)
 
 /* An "available occurrence" is one that is the last occurrence in the
    basic block and the operands are not modified by following statements in
-   the basic block [including this insn].  */
+   the basic block [including this insn].
+
+   For VSETVL instruction, we have these following formats:
+     1. vsetvl zero, rs1.
+     2. vsetvl zero, imm.
+     3. vsetvl rd, rs1.
+
+   So base on these circumstances, a DEM is considered as a local available
+   occurrence should satisfy these following conditions:
+
+     1). rs1 (avl) are not modified by following statements in
+	 the basic block.
+     2). rd (vl) are not modified by following statements in
+	 the basic block.
+
+   Note: We don't need to check VL/VTYPE here since DEM is UNKNOWN if VL/VTYPE
+	 is modified prior to the occurrence. This case is already considered as
+	 a non-local available occurrence.
+*/
 static bool
-available_occurrence_p (const insn_info *insn, const vector_insn_info dem)
+available_occurrence_p (const bb_info *bb, const vector_insn_info dem)
 {
+  insn_info *insn = dem.get_insn ();
   /* The only possible operand we care of VSETVL is AVL.  */
   if (dem.has_avl_reg ())
     {
-      /* The operands should not be modified in the basic block prior
-	 to the occurrence.
-	 e.g.
-	    bb:
-	      vsetvl hr3, hr2, ...
-	      ...
-	      vadd ... (vl=hr3)
-      */
       if (!vlmax_avl_p (dem.get_avl ()))
 	{
-	  set_info *set
-	    = find_access (insn->uses (), REGNO (dem.get_avl ()))->def ();
-	  /* If it's undefined, it's not available conservatively.  */
-	  if (!set)
-	    return false;
-	  if (same_bb_and_after_or_equal_p (set->insn (), insn))
-	    return false;
+	  rtx dest = NULL_RTX;
+	  if (vsetvl_insn_p (insn->rtl ()))
+	    dest = get_vl (insn->rtl ());
+	  for (const insn_info *i = insn; real_insn_and_same_bb_p (i, bb);
+	       i = i->next_nondebug_insn ())
+	    {
+	      /* rs1 (avl) are not modified by following statements in
+		 the basic block.  */
+	      if (find_access (i->defs (), REGNO (dem.get_avl ())))
+		return false;
+	      /* rd (vl) are not modified by following statements in
+		 the basic block.  */
+	      if (dest && find_access (i->defs (), REGNO (dest)))
+		return false;
+	    }
 	}
     }
   return true;
 }
 
-/* Return true if the branch probability is dominate.  */
-static bool
-dominate_probability_p (edge e)
-{
-  /* TODO: We simpily pick dominate probability >= 50%.
-     However, it isn't always optimal. Consider cases
-     like this:
-       bb 0: 80% succs: bb 2, bb 3, bb 4, bb 5.
-       bb 1: 20%
-
-     Assume bb 1, bb 2, bb 3, bb 4, bb 5 are different
-     one another, and bb 2, bb 3, bb 4, bb 5 are incompatible.
-
-     ??? Maybe backward propagate bb 1 is better ???
-     May need to support an accurate and reliable COST model
-     in the future.  */
-  return e->probability >= profile_probability::even ();
-}
-
 /* Return true if the block is worthwhile backward propagation.  */
 static bool
 backward_propagate_worthwhile_p (const basic_block cfg_bb,
@@ -271,48 +376,139 @@ backward_propagate_worthwhile_p (const basic_block cfg_bb,
 {
   if (loop_basic_block_p (cfg_bb))
     {
-      if (block_info.local_dem.compatible_p (block_info.reaching_out))
-	return true;
-
-      /* There is a obvious case that is not worthwhile and meaningless
-	 to propagate the demand information:
-			  local_dem
-			     __________
-			 ____|____     |
-			|        |     |
-			|________|     |
-			     |_________|
-			  reaching_out
-	  Header is incompatible with reaching_out and the block is loop itself,
-	  we don't backward propagate the local_dem since we can't avoid emit
-	  vsetvl for the local_dem.  */
-      edge e;
-      edge_iterator ei;
-      FOR_EACH_EDGE (e, ei, cfg_bb->succs)
-	if (e->dest->index == cfg_bb->index)
+      if (block_info.reaching_out.valid_or_dirty_p ())
+	{
+	  if (block_info.local_dem.compatible_p (block_info.reaching_out))
+	    {
+	      /* Case 1 (Can backward propagate):
+		 ....
+		 bb0:
+		 ...
+		 for (int i = 0; i < n; i++)
+		   {
+		     vint16mf4_t v = __riscv_vle16_v_i16mf4 (in + i + 5, 7);
+		     __riscv_vse16_v_i16mf4 (out + i + 5, v, 7);
+		   }
+		 The local_dem is compatible with reaching_out. Such case is
+		 worthwhile backward propagation.  */
+	      return true;
+	    }
+	  else
+	    {
+	      /* Case 2 (Don't backward propagate):
+		    ....
+		    bb0:
+		    ...
+		    for (int i = 0; i < n; i++)
+		      {
+			vint16mf4_t v = __riscv_vle16_v_i16mf4 (in + i + 5, 7);
+			__riscv_vse16_v_i16mf4 (out + i + 5, v, 7);
+			vint16mf2_t v2 = __riscv_vle16_v_i16mf2 (in + i + 6, 8);
+			__riscv_vse16_v_i16mf2 (out + i + 6, v, 8);
+		      }
+		 The local_dem is incompatible with reaching_out.
+		 It makes no sense to backward propagate the local_dem since we
+		 can't avoid VSETVL inside the loop.  */
+	      return false;
+	    }
+	}
+      else
+	{
+	  gcc_assert (block_info.reaching_out.unknown_p ());
+	  /* Case 3 (Don't backward propagate):
+		....
+		bb0:
+		...
+		for (int i = 0; i < n; i++)
+		  {
+		    vint16mf4_t v = __riscv_vle16_v_i16mf4 (in + i + 5, 7);
+		    __riscv_vse16_v_i16mf4 (out + i + 5, v, 7);
+		    fn3 ();
+		  }
+	    The local_dem is VALID, but the reaching_out is UNKNOWN.
+	    It makes no sense to backward propagate the local_dem since we
+	    can't avoid VSETVL inside the loop.  */
 	  return false;
+	}
     }
 
   return true;
 }
 
-/* Helper function to get VL operand.  */
-static rtx
-get_vl (rtx_insn *rinsn)
+static bool
+insn_should_be_added_p (const insn_info *insn, unsigned int types)
 {
-  if (has_vl_op (rinsn))
+  if (insn->is_real () && (types & REAL_SET))
+    return true;
+  if (insn->is_phi () && (types & PHI_SET))
+    return true;
+  if (insn->is_bb_head () && (types & BB_HEAD_SET))
+    return true;
+  if (insn->is_bb_end () && (types & BB_END_SET))
+    return true;
+  return false;
+}
+
+/* Recursively find all define instructions. The kind of instruction is
+   specified by the DEF_TYPE.  */
+static hash_set<set_info *>
+get_all_sets (phi_info *phi, unsigned int types)
+{
+  hash_set<set_info *> insns;
+  auto_vec<phi_info *> work_list;
+  hash_set<phi_info *> visited_list;
+  if (!phi)
+    return hash_set<set_info *> ();
+  work_list.safe_push (phi);
+
+  while (!work_list.is_empty ())
     {
-      extract_insn_cached (rinsn);
-      return recog_data.operand[get_attr_vl_op_idx (rinsn)];
+      phi_info *phi = work_list.pop ();
+      visited_list.add (phi);
+      for (use_info *use : phi->inputs ())
+	{
+	  def_info *def = use->def ();
+	  set_info *set = safe_dyn_cast<set_info *> (def);
+	  if (!set)
+	    return hash_set<set_info *> ();
+
+	  gcc_assert (!set->insn ()->is_debug_insn ());
+
+	  if (insn_should_be_added_p (set->insn (), types))
+	    insns.add (set);
+	  if (set->insn ()->is_phi ())
+	    {
+	      phi_info *new_phi = as_a<phi_info *> (set);
+	      if (!visited_list.contains (new_phi))
+		work_list.safe_push (new_phi);
+	    }
+	}
     }
-  return SET_DEST (XVECEXP (PATTERN (rinsn), 0, 0));
+  return insns;
+}
+
+static hash_set<set_info *>
+get_all_sets (set_info *set, bool /* get_real_inst */ real_p,
+	      bool /*get_phi*/ phi_p, bool /* get_function_parameter*/ param_p)
+{
+  if (real_p && phi_p && param_p)
+    return get_all_sets (safe_dyn_cast<phi_info *> (set),
+			 REAL_SET | PHI_SET | BB_HEAD_SET | BB_END_SET);
+
+  else if (real_p && param_p)
+    return get_all_sets (safe_dyn_cast<phi_info *> (set),
+			 REAL_SET | BB_HEAD_SET | BB_END_SET);
+
+  else if (real_p)
+    return get_all_sets (safe_dyn_cast<phi_info *> (set), REAL_SET);
+  return hash_set<set_info *> ();
 }
 
 /* Helper function to get AVL operand.  */
 static rtx
 get_avl (rtx_insn *rinsn)
 {
-  if (vsetvl_insn_p (rinsn))
+  if (vsetvl_insn_p (rinsn) || vsetvl_discard_result_insn_p (rinsn))
     return XVECEXP (SET_SRC (XVECEXP (PATTERN (rinsn), 0, 0)), 0, 0);
 
   if (!has_vl_op (rinsn))
@@ -323,97 +519,48 @@ get_avl (rtx_insn *rinsn)
   return recog_data.operand[get_attr_vl_op_idx (rinsn)];
 }
 
-static bool
-can_backward_propagate_p (const function_info *ssa, const basic_block cfg_bb,
-			  const vector_insn_info prop)
+static set_info *
+get_same_bb_set (hash_set<set_info *> &sets, const basic_block cfg_bb)
 {
-  insn_info *insn = prop.get_insn ();
-
-  /* TODO: We don't backward propagate the explict VSETVL here
-     since we will change vsetvl and vsetvlmax intrinsics into
-     no side effects which can be optimized into optimal location
-     by GCC internal passes. We only need to support these backward
-     propagation if vsetvl intrinsics have side effects.  */
-  if (vsetvl_insn_p (insn->rtl ()))
-    return false;
+  for (set_info *set : sets)
+    if (set->bb ()->cfg_bb () == cfg_bb)
+      return set;
+  return nullptr;
+}
 
-  gcc_assert (has_vtype_op (insn->rtl ()));
-  rtx reg = NULL_RTX;
+/* Recursively find all predecessor blocks for cfg_bb. */
+static hash_set<basic_block>
+get_all_predecessors (basic_block cfg_bb)
+{
+  hash_set<basic_block> blocks;
+  auto_vec<basic_block> work_list;
+  hash_set<basic_block> visited_list;
+  work_list.safe_push (cfg_bb);
 
-  /* Case 1: Don't need VL. Just let it backward propagate.  */
-  if (!has_vl_op (insn->rtl ()))
-    return true;
-  else
+  while (!work_list.is_empty ())
     {
-      /* Case 2: CONST_INT AVL, we don't need to check def.  */
-      if (prop.has_avl_imm ())
-	return true;
-      else
+      basic_block new_cfg_bb = work_list.pop ();
+      visited_list.add (new_cfg_bb);
+      edge e;
+      edge_iterator ei;
+      FOR_EACH_EDGE (e, ei, new_cfg_bb->preds)
 	{
-	  /* Case 3: REG AVL, we need to check the distance of def to make
-	     sure we won't backward propagate over the def.  */
-	  gcc_assert (prop.has_avl_reg ());
-	  if (vlmax_avl_p (prop.get_avl ()))
-	    /* Check VL operand for vsetvl vl,zero.  */
-	    reg = get_vl (insn->rtl ());
-	  else
-	    /* Check AVL operand for vsetvl zero,avl.  */
-	    reg = get_avl (insn->rtl ());
+	  if (!visited_list.contains (e->src))
+	    work_list.safe_push (e->src);
+	  blocks.add (e->src);
 	}
     }
+  return blocks;
+}
 
-  def_info *def = find_access (insn->uses (), REGNO (reg))->def ();
-
-  /* If the definition is in the current block, we can't propagate it
-     across blocks.  */
-  if (def->bb ()->cfg_bb ()->index == insn->bb ()->cfg_bb ()->index)
-    {
-      set_info *set = safe_dyn_cast<set_info *> (def);
-
-      /* True if it is a degenerate PHI that can be backward propagated.  */
-      auto valid_degenerate_phi_p = [&] () {
-	if (!set)
-	  return false;
-
-	phi_info *phi = safe_dyn_cast<phi_info *> (set);
-	if (!phi)
-	  return false;
-
-	basic_block iter_bb;
-	set_info *ultimate_def = look_through_degenerate_phi (set);
-	const basic_block ultimate_bb = ultimate_def->bb ()->cfg_bb ();
-	FOR_BB_BETWEEN (iter_bb, ultimate_bb, def->bb ()->cfg_bb (), next_bb)
-	  if (iter_bb->index == cfg_bb->index)
-	    return true;
-
-	return false;
-      };
-
-      if (valid_degenerate_phi_p ())
-	return true;
-
-      /* TODO: Support non-degenerate PHI backward propagation later.  */
-      return false;
-    }
-
-  /* If the definition block is the current block that we iterate, we
-     can backward propagate it since we will insert or change VL/VTYPE
-     info at the end of the current block we iterate.  */
-  if (def->bb ()->cfg_bb ()->index == cfg_bb->index)
-    return true;
-
-  /* Make sure we don't backward propagate the VL/VTYPE info over the
-     definition blocks.  */
-  bool visited_p = false;
-  for (const bb_info *bb : ssa->reverse_bbs ())
-    {
-      if (bb->cfg_bb ()->index == cfg_bb->index && visited_p)
-	return false;
-      if (bb->cfg_bb ()->index == def->bb ()->cfg_bb ()->index)
-	visited_p = true;
-    }
-
-  return true;
+/* Return true if there is an INSN in insns staying in the block BB.  */
+static bool
+any_set_in_bb_p (hash_set<set_info *> sets, const bb_info *bb)
+{
+  for (const set_info *set : sets)
+    if (set->bb ()->index () == bb->index ())
+      return true;
+  return false;
 }
 
 /* Helper function to get SEW operand. We always have SEW value for
@@ -487,7 +634,7 @@ has_vector_insn (function *fn)
 
 /* Emit vsetvl instruction.  */
 static rtx
-gen_vsetvl_pat (enum vsetvl_type insn_type, vl_vtype_info info, rtx vl)
+gen_vsetvl_pat (enum vsetvl_type insn_type, const vl_vtype_info &info, rtx vl)
 {
   rtx avl = info.get_avl ();
   rtx sew = gen_int_mode (info.get_sew (), Pmode);
@@ -507,7 +654,7 @@ gen_vsetvl_pat (enum vsetvl_type insn_type, vl_vtype_info info, rtx vl)
 }
 
 static rtx
-gen_vsetvl_pat (rtx_insn *rinsn, const vector_insn_info info)
+gen_vsetvl_pat (rtx_insn *rinsn, const vector_insn_info &info)
 {
   rtx new_pat;
   if (vsetvl_insn_p (rinsn) || vlmax_avl_p (info.get_avl ()))
@@ -524,7 +671,7 @@ gen_vsetvl_pat (rtx_insn *rinsn, const vector_insn_info info)
 
 static void
 emit_vsetvl_insn (enum vsetvl_type insn_type, enum emit_type emit_type,
-		  vl_vtype_info info, rtx vl, rtx_insn *rinsn)
+		  const vl_vtype_info &info, rtx vl, rtx_insn *rinsn)
 {
   rtx pat = gen_vsetvl_pat (insn_type, info, vl);
   if (dump_file)
@@ -562,7 +709,7 @@ insert_vsetvl (enum emit_type emit_type, rtx_insn *rinsn,
   /* Use X0, X0 form if the AVL is the same and the SEW+LMUL gives the same
      VLMAX.  */
   if (prev_info.valid_or_dirty_p () && !prev_info.unknown_p ()
-      && info.same_avl_p (prev_info) && info.same_vlmax_p (prev_info))
+      && info.compatible_avl_p (prev_info) && info.same_vlmax_p (prev_info))
     {
       emit_vsetvl_insn (VSETVL_VTYPE_CHANGE_ONLY, emit_type, info, NULL_RTX,
 			rinsn);
@@ -627,7 +774,7 @@ insert_vsetvl (enum emit_type emit_type, rtx_insn *rinsn,
    necessary REG_LABEL_OPERAND and REG_LABEL_TARGET notes.  */
 
 static void
-add_label_notes (rtx x, rtx_insn *insn)
+add_label_notes (rtx x, rtx_insn *rinsn)
 {
   enum rtx_code code = GET_CODE (x);
   int i, j;
@@ -644,8 +791,8 @@ add_label_notes (rtx x, rtx_insn *insn)
       /* There's no reason for current users to emit jump-insns with
 	 such a LABEL_REF, so we don't have to handle REG_LABEL_TARGET
 	 notes.  */
-      gcc_assert (!JUMP_P (insn));
-      add_reg_note (insn, REG_LABEL_OPERAND, label_ref_label (x));
+      gcc_assert (!JUMP_P (rinsn));
+      add_reg_note (rinsn, REG_LABEL_OPERAND, label_ref_label (x));
 
       if (LABEL_P (label_ref_label (x)))
 	LABEL_NUSES (label_ref_label (x))++;
@@ -656,10 +803,10 @@ add_label_notes (rtx x, rtx_insn *insn)
   for (i = GET_RTX_LENGTH (code) - 1, fmt = GET_RTX_FORMAT (code); i >= 0; i--)
     {
       if (fmt[i] == 'e')
-	add_label_notes (XEXP (x, i), insn);
+	add_label_notes (XEXP (x, i), rinsn);
       else if (fmt[i] == 'E')
 	for (j = XVECLEN (x, i) - 1; j >= 0; j--)
-	  add_label_notes (XVECEXP (x, i, j), insn);
+	  add_label_notes (XVECEXP (x, i, j), rinsn);
     }
 }
 
@@ -741,10 +888,6 @@ insert_insn_end_basic_block (rtx_insn *rinsn, basic_block cfg_bb)
 static vl_vtype_info
 get_vl_vtype_info (const insn_info *insn)
 {
-  if (vector_config_insn_p (insn->rtl ()))
-    gcc_assert (vsetvl_insn_p (insn->rtl ())
-		&& "Can't handle X0, rs1 vsetvli yet");
-
   set_info *set = nullptr;
   rtx avl = ::get_avl (insn->rtl ());
   if (avl && REG_P (avl) && !vlmax_avl_p (avl))
@@ -787,7 +930,7 @@ change_insn (rtx_insn *rinsn, rtx new_pat)
       print_rtl_single (dump_file, PATTERN (rinsn));
     }
 
-  validate_change (rinsn, &PATTERN (rinsn), new_pat, true);
+  validate_change (rinsn, &PATTERN (rinsn), new_pat, false);
 
   if (dump_file)
     {
@@ -829,6 +972,107 @@ change_insn (function_info *ssa, insn_change change, insn_info *insn,
   return true;
 }
 
+static void
+change_vsetvl_insn (const insn_info *insn, const vector_insn_info &info)
+{
+  rtx_insn *rinsn;
+  if (vector_config_insn_p (insn->rtl ()))
+    {
+      rinsn = insn->rtl ();
+      gcc_assert (vsetvl_insn_p (rinsn) && "Can't handle X0, rs1 vsetvli yet");
+    }
+  else
+    {
+      gcc_assert (has_vtype_op (insn->rtl ()));
+      rinsn = PREV_INSN (insn->rtl ());
+      gcc_assert (vector_config_insn_p (rinsn));
+    }
+  rtx new_pat = gen_vsetvl_pat (rinsn, info);
+  change_insn (rinsn, new_pat);
+}
+
+static bool
+source_equal_p (insn_info *insn1, insn_info *insn2)
+{
+  if (!insn1 || !insn2)
+    return false;
+  rtx_insn *rinsn1 = insn1->rtl ();
+  rtx_insn *rinsn2 = insn2->rtl ();
+  if (!rinsn1 || !rinsn2)
+    return false;
+  rtx note1 = find_reg_equal_equiv_note (rinsn1);
+  rtx note2 = find_reg_equal_equiv_note (rinsn2);
+  rtx single_set1 = single_set (rinsn1);
+  rtx single_set2 = single_set (rinsn2);
+
+  if (note1 && note2 && rtx_equal_p (note1, note2))
+    return true;
+
+  /* Since vsetvl instruction is not single SET.
+     We handle this case specially here.  */
+  if (vsetvl_insn_p (insn1->rtl ()) && vsetvl_insn_p (insn2->rtl ()))
+    {
+      /* For example:
+	   vsetvl1 a6,a5,e32m1
+	   RVV 1 (use a6 as AVL)
+	   vsetvl2 a5,a5,e8mf4
+	   RVV 2 (use a5 as AVL)
+	 We consider AVL of RVV 1 and RVV 2 are same so that we can
+	 gain more optimization opportunities.
+
+	 Note: insn1_info.compatible_avl_p (insn2_info)
+	 will make sure there is no instruction between vsetvl1 and vsetvl2
+	 modify a5 since their def will be different if there is instruction
+	 modify a5 and compatible_avl_p will return false.  */
+      vector_insn_info insn1_info, insn2_info;
+      insn1_info.parse_insn (insn1);
+      insn2_info.parse_insn (insn2);
+      if (insn1_info.same_vlmax_p (insn2_info)
+	  && insn1_info.compatible_avl_p (insn2_info))
+	return true;
+    }
+
+  /* We only handle AVL is set by instructions with no side effects.  */
+  if (!single_set1 || !single_set2)
+    return false;
+  if (!rtx_equal_p (SET_SRC (single_set1), SET_SRC (single_set2)))
+    return false;
+  gcc_assert (insn1->uses ().size () == insn2->uses ().size ());
+  for (size_t i = 0; i < insn1->uses ().size (); i++)
+    if (insn1->uses ()[i] != insn2->uses ()[i])
+      return false;
+  return true;
+}
+
+/* Helper function to get single same real RTL source.
+   return NULL if it is not a single real RTL source.  */
+static insn_info *
+extract_single_source (set_info *set)
+{
+  if (!set)
+    return nullptr;
+  if (set->insn ()->is_real ())
+    return set->insn ();
+  if (!set->insn ()->is_phi ())
+    return nullptr;
+  hash_set<set_info *> sets = get_all_sets (set, true, false, true);
+
+  insn_info *first_insn = (*sets.begin ())->insn ();
+  if (first_insn->is_artificial ())
+    return nullptr;
+  for (const set_info *set : sets)
+    {
+      /* If there is a head or end insn, we conservative return
+	 NULL so that VSETVL PASS will insert vsetvl directly.  */
+      if (set->insn ()->is_artificial ())
+	return nullptr;
+      if (!source_equal_p (set->insn (), first_insn))
+	return nullptr;
+    }
+
+  return first_insn;
+}
+
 avl_info::avl_info (const avl_info &other)
 {
   m_value = other.get_value ();
@@ -839,6 +1083,89 @@ avl_info::avl_info (rtx value_in, set_info *source_in)
   : m_value (value_in), m_source (source_in)
 {}
 
+bool
+avl_info::single_source_equal_p (const avl_info &other) const
+{
+  set_info *set1 = m_source;
+  set_info *set2 = other.get_source ();
+  insn_info *insn1 = extract_single_source (set1);
+  insn_info *insn2 = extract_single_source (set2);
+  if (!insn1 || !insn2)
+    return false;
+  return source_equal_p (insn1, insn2);
+}
+
+bool
+avl_info::multiple_source_equal_p (const avl_info &other) const
+{
+  /* TODO: We don't do too much optimization here since it's
+     too complicated in case of analyzing the PHI node.
+
+     For example:
+       void f (void * restrict in, void * restrict out, int n, int m, int cond)
+	{
+	  size_t vl;
+	  switch (cond)
+	  {
+	  case 1:
+	    vl = 100;
+	    break;
+	  case 2:
+	    vl = *(size_t*)(in + 100);
+	    break;
+	  case 3:
+	    {
+	      size_t new_vl = *(size_t*)(in + 500);
+	      size_t new_vl2 = *(size_t*)(in + 600);
+	      vl = new_vl + new_vl2 + 777;
+	      break;
+	    }
+	  default:
+	    vl = 4000;
+	    break;
+	  }
+	  for (size_t i = 0; i < n; i++)
+	    {
+	      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i, vl);
+	      __riscv_vse8_v_i8mf8 (out + i, v, vl);
+
+	      vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + i + 100, vl);
+	      __riscv_vse8_v_i8mf8 (out + i + 100, v2, vl);
+	    }
+
+	  size_t vl2;
+	  switch (cond)
+	  {
+	  case 1:
+	    vl2 = 100;
+	    break;
+	  case 2:
+	    vl2 = *(size_t*)(in + 100);
+	    break;
+	  case 3:
+	    {
+	      size_t new_vl = *(size_t*)(in + 500);
+	      size_t new_vl2 = *(size_t*)(in + 600);
+	      vl2 = new_vl + new_vl2 + 777;
+	      break;
+	    }
+	  default:
+	    vl2 = 4000;
+	    break;
+	  }
+	  for (size_t i = 0; i < m; i++)
+	    {
+	      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + 300, vl2);
+	      __riscv_vse8_v_i8mf8 (out + i + 300, v, vl2);
+	      vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + i + 200, vl2);
+	      __riscv_vse8_v_i8mf8 (out + i + 200, v2, vl2);
+	    }
+	}
+     Such case may not be necessary to optimize since the codes of defining
+     vl and vl2 are redundant.  */
+  return m_source == other.get_source ();
+}
+
 avl_info &
 avl_info::operator= (const avl_info &other)
 {
@@ -855,11 +1182,6 @@ avl_info::operator== (const avl_info &other) const
   if (!other.get_value ())
     return false;
 
-  /* It's safe to consider they are equal if their RTX value are
-     strictly the same.  */
-  if (m_value == other.get_value ())
-    return true;
-
   if (GET_CODE (m_value) != GET_CODE (other.get_value ()))
     return false;
 
@@ -871,9 +1193,16 @@ avl_info::operator== (const avl_info &other) const
   if (vlmax_avl_p (m_value))
     return vlmax_avl_p (other.get_value ());
 
-  /* TODO: So far we only support VLMAX (AVL=zero) comparison,
-     we will support non-VLMAX AVL in the future.  */
-  return false;
+  /* If any source is undef value, we think they are not equal.  */
+  if (!m_source || !other.get_source ())
+    return false;
+
+  /* If both sources are single source (defined by a single real RTL)
+     and their definitions are same.  */
+  if (single_source_equal_p (other))
+    return true;
+
+  return multiple_source_equal_p (other);
 }
 
 bool
@@ -895,7 +1224,7 @@ vl_vtype_info::vl_vtype_info (avl_info avl_in, uint8_t sew_in,
 bool
 vl_vtype_info::operator== (const vl_vtype_info &other) const
 {
-  return m_avl == other.get_avl_info () && m_sew == other.get_sew ()
+  return same_avl_p (other) && m_sew == other.get_sew ()
 	 && m_vlmul == other.get_vlmul () && m_ta == other.get_ta ()
 	 && m_ma == other.get_ma () && m_ratio == other.get_ratio ();
 }
@@ -919,7 +1248,12 @@ vl_vtype_info::has_non_zero_avl () const
 bool
 vl_vtype_info::same_avl_p (const vl_vtype_info &other) const
 {
-  return get_avl_info () == other.get_avl_info ();
+  /* We need to compare both RTL and SET. If both AVL are CONST_INT.
+     For example, const_int 3 and const_int 4, we need to compare
+     RTL. If both AVL are REG and their REGNO are same, we need to
+     compare SET.  */
+  return get_avl () == other.get_avl ()
+	 && get_avl_source () == other.get_avl_source ();
 }
 
 bool
@@ -978,12 +1312,10 @@ vector_insn_info::operator>= (const vector_insn_info &other) const
 	}
     }
 
-  if (demand_p (DEMAND_TAIL_POLICY) && !other.demand_p (DEMAND_TAIL_POLICY)
-      && get_ta () != other.get_ta ())
+  if (!demand_p (DEMAND_TAIL_POLICY) && other.demand_p (DEMAND_TAIL_POLICY))
     return false;
 
-  if (demand_p (DEMAND_MASK_POLICY) && !other.demand_p (DEMAND_MASK_POLICY)
-      && get_ma () != other.get_ma ())
+  if (!demand_p (DEMAND_MASK_POLICY) && other.demand_p (DEMAND_MASK_POLICY))
     return false;
 
   return true;
@@ -1011,10 +1343,10 @@ vector_insn_info::operator== (const vector_insn_info &other) const
     if (m_demands[i] != other.demand_p ((enum demand_type) i))
       return false;
 
-  if (m_insn != other.get_insn ())
-    return false;
-  if (m_dirty_pat != other.get_dirty_pat ())
-    return false;
+  if (vector_config_insn_p (m_insn->rtl ())
+      || vector_config_insn_p (other.get_insn ()->rtl ()))
+    if (m_insn != other.get_insn ())
+      return false;
 
   if (!same_avl_p (other))
     return false;
@@ -1102,6 +1434,25 @@ vector_insn_info::parse_insn (insn_info *insn)
     m_demands[DEMAND_TAIL_POLICY] = true;
   if (get_attr_ma (insn->rtl ()) != INVALID_ATTRIBUTE)
     m_demands[DEMAND_MASK_POLICY] = true;
+
+  if (vector_config_insn_p (insn->rtl ()))
+    return;
+
+  if (!has_avl_reg () || !m_avl.get_source ()
+      || !m_avl.get_source ()->insn ()->is_phi ())
+    return;
+
+  insn_info *def_insn = extract_single_source (m_avl.get_source ());
+  if (def_insn)
+    {
+      vector_insn_info new_info;
+      new_info.parse_insn (def_insn);
+      if (!same_vlmax_p (new_info))
+	return;
+      /* TODO: Currently, we don't forward AVL for non-VLMAX vsetvl.  */
+      if (vlmax_avl_p (new_info.get_avl ()))
+	set_avl_info (new_info.get_avl_info ());
+    }
 }
 
 void
@@ -1150,7 +1501,7 @@ vector_insn_info::compatible_p (const vector_insn_info &other) const
     return false;
 
   if (demand_p (DEMAND_AVL) && other.demand_p (DEMAND_AVL))
-    return m_avl == other.get_avl_info ();
+    return compatible_avl_p (other);
 
   return true;
 }
@@ -1166,6 +1517,15 @@ vector_insn_info::compatible_avl_p (const vl_vtype_info &other) const
 }
 
 bool
+vector_insn_info::compatible_avl_p (const avl_info &other) const
+{
+  gcc_assert (valid_or_dirty_p () && "Can't compare invalid vl_vtype_info");
+  gcc_assert (!unknown_p () && "Can't compare AVL in unknown state");
+  gcc_assert (demand_p (DEMAND_AVL) && "Can't compare AVL undemand state");
+  return get_avl_info () == other;
+}
+
+bool
 vector_insn_info::compatible_vtype_p (const vl_vtype_info &other) const
 {
   gcc_assert (valid_or_dirty_p () && "Can't compare invalid vl_vtype_info");
@@ -1206,33 +1566,50 @@ vector_insn_info::compatible_p (const vl_vtype_info &curr_info) const
   return compatible_avl_p (curr_info) && compatible_vtype_p (curr_info);
 }
 
+bool
+vector_insn_info::available_p (const vector_insn_info &other) const
+{
+  if (*this >= other)
+    return true;
+  return false;
+}
+
 vector_insn_info
 vector_insn_info::merge (const vector_insn_info &merge_info,
-			 bool across_bb_p = false) const
+			 enum merge_type type = LOCAL_MERGE) const
 {
-  gcc_assert (this->compatible_p (merge_info)
-	      && "Can't merge incompatible demanded infos");
+  if (!vsetvl_insn_p (get_insn ()->rtl ()))
+    gcc_assert (this->compatible_p (merge_info)
+		&& "Can't merge incompatible demanded infos");
 
   vector_insn_info new_info;
   new_info.demand_vl_vtype ();
 
-  if (dirty_p ())
+  if (type == LOCAL_MERGE)
     {
-      gcc_assert (across_bb_p);
-      if (demand_p (DEMAND_AVL))
-	new_info.set_insn (get_insn ());
-      else
-	new_info.set_insn (merge_info.get_insn ());
+      /* For local backward data flow, we always update INSN && AVL as the
+	 latest INSN and AVL so that we can keep track status of each INSN.*/
+      new_info.set_insn (merge_info.get_insn ());
+      if (merge_info.demand_p (DEMAND_AVL))
+	new_info.set_avl_info (merge_info.get_avl_info ());
+      else if (demand_p (DEMAND_AVL))
+	new_info.set_avl_info (get_avl_info ());
     }
   else
     {
-      if (across_bb_p)
-	new_info.set_insn (get_insn ());
-      else
-	new_info.set_insn (merge_info.get_insn ());
-    }
+      /* For global data flow, we should keep original INSN and AVL if they
+	 valid since we should keep the life information of each block.
 
-  new_info.set_dirty_pat (merge_info.get_dirty_pat ());
+	 For example:
+	   bb 0 -> bb 1.
+	 We should keep INSN && AVL of bb 1 since we will eventually emit
+	 vsetvl instruction according to INSN and AVL of bb 1.  */
+      new_info.set_insn (get_insn ());
+      if (demand_p (DEMAND_AVL))
+	new_info.set_avl_info (get_avl_info ());
+      else if (merge_info.demand_p (DEMAND_AVL))
+	new_info.set_avl_info (merge_info.get_avl_info ());
+    }
 
   if (!demand_p (DEMAND_AVL) && !merge_info.demand_p (DEMAND_AVL))
     new_info.undemand (DEMAND_AVL);
@@ -1248,11 +1625,6 @@ vector_insn_info::merge (const vector_insn_info &merge_info,
       && !merge_info.demand_p (DEMAND_MASK_POLICY))
     new_info.undemand (DEMAND_MASK_POLICY);
 
-  if (merge_info.demand_p (DEMAND_AVL))
-    new_info.set_avl_info (merge_info.get_avl_info ());
-  else if (demand_p (DEMAND_AVL))
-    new_info.set_avl_info (get_avl_info ());
-
   if (merge_info.demand_p (DEMAND_SEW))
     new_info.set_sew (merge_info.get_sew ());
   else if (demand_p (DEMAND_SEW))
@@ -1320,6 +1692,10 @@ vector_insn_info::dump (FILE *file) const
     fprintf (file, "UNKNOWN,");
   else if (empty_p ())
     fprintf (file, "EMPTY,");
+  else if (hard_empty_p ())
+    fprintf (file, "HARD_EMPTY,");
+  else if (dirty_with_killed_avl_p ())
+    fprintf (file, "DIRTY_WITH_KILLED_AVL,");
   else
     fprintf (file, "DIRTY,");
 
@@ -1346,11 +1722,6 @@ vector_insn_info::dump (FILE *file) const
 	  fprintf (file, "The real INSN=");
 	  print_rtl_single (file, get_insn ()->rtl ());
 	}
-      if (get_dirty_pat ())
-	{
-	  fprintf (file, "Dirty RTL Pattern=");
-	  print_rtl_single (file, get_dirty_pat ());
-	}
     }
 }
 
@@ -1387,6 +1758,7 @@ vector_infos_manager::vector_infos_manager ()
 	  vector_block_infos[bb->index ()].reaching_out = vector_insn_info ();
 	  for (insn_info *insn : bb->real_insns ())
 	    vector_insn_infos[insn->uid ()].parse_insn (insn);
+	  vector_block_infos[bb->index ()].probability = profile_probability ();
 	}
     }
 }
@@ -1415,7 +1787,7 @@ vector_infos_manager::get_all_available_exprs (
 {
   auto_vec<size_t> available_list;
   for (size_t i = 0; i < vector_exprs.length (); i++)
-    if (info >= *vector_exprs[i])
+    if (info.available_p (*vector_exprs[i]))
       available_list.safe_push (i);
   return available_list;
 }
@@ -1440,6 +1812,29 @@ vector_infos_manager::all_same_ratio_p (sbitmap bitdata) const
   return true;
 }
 
+bool
+vector_infos_manager::all_same_avl_p (const basic_block cfg_bb,
+				      sbitmap bitdata) const
+{
+  if (bitmap_empty_p (bitdata))
+    return false;
+
+  const auto &block_info = vector_block_infos[cfg_bb->index];
+  if (!block_info.local_dem.demand_p (DEMAND_AVL))
+    return true;
+
+  avl_info avl = block_info.local_dem.get_avl_info ();
+  unsigned int bb_index;
+  sbitmap_iterator sbi;
+
+  EXECUTE_IF_SET_IN_BITMAP (bitdata, 0, bb_index, sbi)
+  {
+    if (vector_exprs[bb_index]->get_avl_info () != avl)
+      return false;
+  }
+  return true;
+}
+
 size_t
 vector_infos_manager::expr_set_num (sbitmap bitdata) const
 {
@@ -1461,18 +1856,62 @@ vector_infos_manager::release (void)
     vector_exprs.release ();
 
   if (optimize > 0)
-    {
-      /* Finished. Free up all the things we've allocated.  */
-      free_edge_list (vector_edge_list);
-      sbitmap_vector_free (vector_del);
-      sbitmap_vector_free (vector_insert);
-      sbitmap_vector_free (vector_kill);
-      sbitmap_vector_free (vector_antic);
-      sbitmap_vector_free (vector_transp);
-      sbitmap_vector_free (vector_comp);
-      sbitmap_vector_free (vector_avin);
-      sbitmap_vector_free (vector_avout);
-    }
+    free_bitmap_vectors ();
+}
+
+void
+vector_infos_manager::create_bitmap_vectors (void)
+{
+  /* Create the bitmap vectors.  */
+  vector_antic = sbitmap_vector_alloc (last_basic_block_for_fn (cfun),
+				       vector_exprs.length ());
+  vector_transp = sbitmap_vector_alloc (last_basic_block_for_fn (cfun),
+					vector_exprs.length ());
+  vector_comp = sbitmap_vector_alloc (last_basic_block_for_fn (cfun),
+				      vector_exprs.length ());
+  vector_avin = sbitmap_vector_alloc (last_basic_block_for_fn (cfun),
+				      vector_exprs.length ());
+  vector_avout = sbitmap_vector_alloc (last_basic_block_for_fn (cfun),
+				       vector_exprs.length ());
+  vector_kill = sbitmap_vector_alloc (last_basic_block_for_fn (cfun),
+				      vector_exprs.length ());
+
+  bitmap_vector_ones (vector_transp, last_basic_block_for_fn (cfun));
+  bitmap_vector_clear (vector_antic, last_basic_block_for_fn (cfun));
+  bitmap_vector_clear (vector_comp, last_basic_block_for_fn (cfun));
+}
+
+void
+vector_infos_manager::free_bitmap_vectors (void)
+{
+  /* Finished. Free up all the things we've allocated.  */
+  free_edge_list (vector_edge_list);
+  if (vector_del)
+    sbitmap_vector_free (vector_del);
+  if (vector_insert)
+    sbitmap_vector_free (vector_insert);
+  if (vector_kill)
+    sbitmap_vector_free (vector_kill);
+  if (vector_antic)
+    sbitmap_vector_free (vector_antic);
+  if (vector_transp)
+    sbitmap_vector_free (vector_transp);
+  if (vector_comp)
+    sbitmap_vector_free (vector_comp);
+  if (vector_avin)
+    sbitmap_vector_free (vector_avin);
+  if (vector_avout)
+    sbitmap_vector_free (vector_avout);
+
+  vector_edge_list = nullptr;
+  vector_kill = nullptr;
+  vector_del = nullptr;
+  vector_insert = nullptr;
+  vector_antic = nullptr;
+  vector_transp = nullptr;
+  vector_comp = nullptr;
+  vector_avin = nullptr;
+  vector_avout = nullptr;
 }
 
 void
@@ -1497,6 +1936,8 @@ vector_infos_manager::dump (FILE *file) const
 	}
       fprintf (file, "<FOOTER>=");
       vector_block_infos[cfg_bb->index].reaching_out.dump (file);
+      fprintf (file, "<Probability>=");
+      vector_block_infos[cfg_bb->index].probability.dump (file);
       fprintf (file, "\n\n");
     }
 
@@ -1600,13 +2041,18 @@ private:
   void emit_local_forward_vsetvls (const bb_info *);
 
   /* Phase 3.  */
-  void merge_successors (const basic_block, const basic_block);
-  void compute_global_backward_infos (void);
+  enum fusion_type get_backward_fusion_type (const bb_info *,
+					     const vector_insn_info &);
+  bool hard_empty_block_p (const bb_info *, const vector_insn_info &) const;
+  bool backward_demand_fusion (void);
+  bool forward_demand_fusion (void);
+  bool cleanup_illegal_dirty_blocks (void);
+  void demand_fusion (void);
 
   /* Phase 4.  */
   void prune_expressions (void);
   void compute_local_properties (void);
-  bool can_refine_vsetvl_p (const basic_block, uint8_t) const;
+  bool can_refine_vsetvl_p (const basic_block, const vector_insn_info &) const;
   void refine_vsetvls (void) const;
   void cleanup_vsetvls (void);
   bool commit_vsetvls (void);
@@ -1615,8 +2061,12 @@ private:
   /* Phase 5.  */
   void cleanup_insns (void) const;
 
+  /* Phase 6.  */
+  void propagate_avl (void) const;
+
   void init (void);
   void done (void);
+  void compute_probabilities (void);
 
 public:
   pass_vsetvl (gcc::context *ctxt) : rtl_opt_pass (pass_data_vsetvl, ctxt) {}
@@ -1774,54 +2224,287 @@ pass_vsetvl::emit_local_forward_vsetvls (const bb_info *bb)
   block_info.reaching_out = curr_info;
 }
 
-/* Merge all successors of Father except child node.  */
-void
-pass_vsetvl::merge_successors (const basic_block father,
-			       const basic_block child)
+enum fusion_type
+pass_vsetvl::get_backward_fusion_type (const bb_info *bb,
+				       const vector_insn_info &prop)
 {
-  edge e;
-  edge_iterator ei;
-  auto &father_info = m_vector_manager->vector_block_infos[father->index];
-  gcc_assert (father_info.local_dem.dirty_p ()
-	      || father_info.local_dem.empty_p ());
-  gcc_assert (father_info.reaching_out.dirty_p ()
-	      || father_info.reaching_out.empty_p ());
+  insn_info *insn = prop.get_insn ();
+
+  /* TODO: We don't backward propagate the explict VSETVL here
+     since we will change vsetvl and vsetvlmax intrinsics into
+     no side effects which can be optimized into optimal location
+     by GCC internal passes. We only need to support these backward
+     propagation if vsetvl intrinsics have side effects.  */
+  if (vsetvl_insn_p (insn->rtl ()))
+    return INVALID_FUSION;
+
+  gcc_assert (has_vtype_op (insn->rtl ()));
+  rtx reg = NULL_RTX;
 
-  FOR_EACH_EDGE (e, ei, father->succs)
+  /* Case 1: Don't need VL. Just let it backward propagate.  */
+  if (!has_vl_op (insn->rtl ()))
+    return VALID_AVL_FUSION;
+  else
     {
-      const basic_block succ = e->dest;
-      if (succ->index == child->index)
-	continue;
+      /* Case 2: CONST_INT AVL, we don't need to check def.  */
+      if (prop.has_avl_imm ())
+	return VALID_AVL_FUSION;
+      else
+	{
+	  /* Case 3: REG AVL, we need to check the distance of def to make
+	     sure we won't backward propagate over the def.  */
+	  gcc_assert (prop.has_avl_reg ());
+	  if (vlmax_avl_p (prop.get_avl ()))
+	    /* Check VL operand for vsetvl vl,zero.  */
+	    reg = get_vl (insn->rtl ());
+	  else
+	    /* Check AVL operand for vsetvl zero,avl.  */
+	    reg = get_avl (insn->rtl ());
+	}
+    }
 
-      const auto succ_info
-	= m_vector_manager->vector_block_infos[succ->index].local_dem;
+  gcc_assert (reg);
+  def_info *def = find_access (insn->uses (), REGNO (reg))->def ();
+  if (!def->insn ()->is_phi () && def->insn ()->bb () == insn->bb ())
+    return INVALID_FUSION;
+  hash_set<set_info *> sets
+    = get_all_sets (prop.get_avl_source (), true, true, true);
+  if (any_set_in_bb_p (sets, insn->bb ()))
+    return INVALID_FUSION;
 
-      if (!succ_info.valid_p ())
-	continue;
+  if (vlmax_avl_p (prop.get_avl ()))
+    {
+      if (find_reg_killed_by (bb, reg))
+	return INVALID_FUSION;
+      else
+	return VALID_AVL_FUSION;
+    }
 
-      vector_insn_info new_info;
-      if (father_info.reaching_out.dirty_p ())
+  /* By default, we always enable backward fusion so that we can
+     gain more optimizations.  */
+  if (!find_reg_killed_by (bb, reg))
+    return VALID_AVL_FUSION;
+  return KILLED_AVL_FUSION;
+}
+
+/* We almost enable all cases in get_backward_fusion_type, this function
+   disable the backward fusion by changing dirty blocks into hard empty
+   blocks in forward dataflow. We can have more accurate optimization by
+   this method.  */
+bool
+pass_vsetvl::hard_empty_block_p (const bb_info *bb,
+				 const vector_insn_info &info) const
+{
+  if (!info.dirty_p () || !info.has_avl_reg ())
+    return false;
+
+  basic_block cfg_bb = bb->cfg_bb ();
+  sbitmap avin = m_vector_manager->vector_avin[cfg_bb->index];
+  rtx avl = vlmax_avl_p (info.get_avl ()) ? get_vl (info.get_insn ()->rtl ())
+					  : get_avl (info.get_insn ()->rtl ());
+  insn_info *insn = info.get_insn ();
+  set_info *set = find_access (insn->uses (), REGNO (avl))->def ();
+  hash_set<set_info *> sets = get_all_sets (set, true, false, false);
+  hash_set<basic_block> pred_cfg_bbs = get_all_predecessors (cfg_bb);
+
+  if (find_reg_killed_by (bb, avl))
+    {
+      /* Condition 1:
+	 Dirty block with killed AVL means that the empty block (no RVV
+	 instructions) are polluted as Dirty blocks with the value of current
+	 AVL is killed. For example:
+	      bb 0:
+		...
+	      bb 1:
+		def a5
+	      bb 2:
+		RVV (use a5)
+	 In backward dataflow, we will polluted BB0 and BB1 as Dirt with AVL
+	 killed. since a5 is killed in BB1.
+	 In this case, let's take a look at this example:
+
+	      bb 3:        bb 4:
+		def3 a5       def4 a5
+	      bb 5:        bb 6:
+		def1 a5       def2 a5
+		    \         /
+		     \       /
+		      \     /
+		       \   /
+			bb 7:
+		    RVV (use a5)
+	 In thi case, we can polluted BB5 and BB6 as dirty if get-def
+	 of a5 from RVV instruction in BB7 is the def1 in BB5 and
+	 def2 BB6 so we can return false early here for HARD_EMPTY_BLOCK_P.
+	 However, we are not sure whether BB3 and BB4 can be
+	 polluted as Dirty with AVL killed so we can't return false
+	 for HARD_EMPTY_BLOCK_P here since it's too early which will
+	 potentially produce issues.  */
+      gcc_assert (info.dirty_with_killed_avl_p ());
+      if (info.get_avl_source ()
+	  && get_same_bb_set (sets, bb->cfg_bb ()) == info.get_avl_source ())
+	return false;
+    }
+
+  /* Condition 2:
+     Suppress the VL/VTYPE info backward propagation too early:
+			 ________
+			|   BB0  |
+			|________|
+			    |
+			____|____
+			|   BB1  |
+			|________|
+     In this case, suppose BB 1 has multiple predecessors, BB 0 is one
+     of them. BB1 has VL/VTYPE info (may be VALID or DIRTY) to backward
+     propagate.
+     The AVIN (available in) which is calculated by LCM is empty only
+     in these 2 circumstances:
+       1. all predecessors of BB1 are empty (not VALID
+	  and can not be polluted in backward fusion flow)
+       2. VL/VTYPE info of BB1 predecessors are conflict.
+
+     We keep it as dirty in 2nd circumstance and set it as HARD_EMPTY
+     (can not be polluted as DIRTY any more) in 1st circumstance.
+     We don't backward propagate in 1st circumstance since there is
+     no VALID RVV instruction and no polluted blocks (dirty blocks)
+     by backward propagation from other following blocks.
+     It's meaningless to keep it as Dirty anymore.
+
+     However, since we keep it as dirty in 2nd since there are VALID or
+     Dirty blocks in predecessors, we can still gain the benefits and
+     optimization opportunities. For example, in this case:
+	for (size_t i = 0; i < n; i++)
+	 {
+	   if (i != cond) {
+	     vint8mf8_t v = *(vint8mf8_t*)(in + i + 100);
+	     *(vint8mf8_t*)(out + i + 100) = v;
+	   } else {
+	     vbool1_t v = *(vbool1_t*)(in + i + 400);
+	     *(vbool1_t*)(out + i + 400) = v;
+	   }
+	 }
+     VL/VTYPE in if-else are conflict which will produce empty AVIN LCM result
+     but we can still keep dirty blocks if *(i != cond)* is very unlikely then
+     we can preset vsetvl (VL/VTYPE) info from else (static propability model).
+
+     We don't want to backward propagate VL/VTYPE information too early
+     which is not the optimal and may potentially produce issues.  */
+  if (bitmap_empty_p (avin))
+    {
+      bool hard_empty_p = true;
+      for (const basic_block pred_cfg_bb : pred_cfg_bbs)
 	{
-	  if (!father_info.reaching_out.compatible_p (succ_info))
+	  if (pred_cfg_bb == ENTRY_BLOCK_PTR_FOR_FN (cfun))
 	    continue;
-
-	  new_info = succ_info.merge (father_info.reaching_out, true);
+	  sbitmap avout = m_vector_manager->vector_avout[pred_cfg_bb->index];
+	  if (!bitmap_empty_p (avout))
+	    {
+	      hard_empty_p = false;
+	      break;
+	    }
 	}
-      else
-	new_info = succ_info;
+      if (hard_empty_p)
+	return true;
+    }
 
-      new_info.set_dirty ();
-      rtx new_pat = gen_vsetvl_pat (new_info.get_insn ()->rtl (), new_info);
-      new_info.set_dirty_pat (new_pat);
+  edge e;
+  edge_iterator ei;
+  bool has_avl_killed_insn_p = false;
+  FOR_EACH_EDGE (e, ei, cfg_bb->succs)
+    {
+      const auto block_info
+	= m_vector_manager->vector_block_infos[e->dest->index];
+      if (block_info.local_dem.dirty_with_killed_avl_p ())
+	{
+	  has_avl_killed_insn_p = true;
+	  break;
+	}
+    }
+  if (!has_avl_killed_insn_p)
+    return false;
 
-      father_info.local_dem = new_info;
-      father_info.reaching_out = new_info;
+  bool any_set_in_bbs_p = false;
+  for (const basic_block pred_cfg_bb : pred_cfg_bbs)
+    {
+      insn_info *def_insn = extract_single_source (set);
+      if (def_insn)
+	{
+	  /* Condition 3:
+
+	    Case 1:                               Case 2:
+		bb 0:                                 bb 0:
+		  def a5 101                             ...
+		bb 1:                                 bb 1:
+		  ...                                    ...
+		bb 2:                                 bb 2:
+		  RVV 1 (use a5 with TAIL ANY)           ...
+		bb 3:                                 bb 3:
+		  def a5 101                             def a5 101
+		bb 4:                                 bb 4:
+		  ...                                    ...
+		bb 5:                                 bb 5:
+		  RVV 2 (use a5 with TU)                 RVV 1 (use a5)
+
+	    Case 1: We can pollute BB3,BB2,BB1,BB0 are all Dirt blocks
+	    with killed AVL so that we can merge TU demand info from RVV 2
+	    into RVV 1 and elide the vsevl instruction in BB5.
+
+	    TODO: We only optimize for single source def since multiple source
+	    def is quite complicated.
+
+	    Case 2: We only can pollute bb 3 as dirty and it has been accepted
+	    in Condition 2 and we can't pollute BB3,BB2,BB1,BB0 like case 1. */
+	  insn_info *last_killed_insn
+	    = find_reg_killed_by (crtl->ssa->bb (pred_cfg_bb), avl);
+	  if (!last_killed_insn || pred_cfg_bb == def_insn->bb ()->cfg_bb ())
+	    continue;
+	  if (source_equal_p (last_killed_insn, def_insn))
+	    {
+	      any_set_in_bbs_p = true;
+	      break;
+	    }
+	}
+      else
+	{
+	  /* Condition 4:
+
+	      bb 0:        bb 1:         bb 3:
+		def1 a5       def2 a5     ...
+		    \         /            /
+		     \       /            /
+		      \     /            /
+		       \   /            /
+			bb 4:          /
+			 |            /
+			 |           /
+			bb 5:       /
+			 |         /
+			 |        /
+			bb 6:    /
+			 |      /
+			 |     /
+			  bb 8:
+			RVV 1 (use a5)
+	  If we get-def (REAL) of a5 from RVV 1 instruction, we will get
+	  def1 from BB0 and def2 from BB1. So we will pollute BB6,BB5,BB4,
+	  BB0,BB1 with DIRTY and set BB3 as HARD_EMPTY so that we won't
+	  propagate AVL to BB3.  */
+	  if (any_set_in_bb_p (sets, crtl->ssa->bb (pred_cfg_bb)))
+	    {
+	      any_set_in_bbs_p = true;
+	      break;
+	    }
+	}
     }
+  if (!any_set_in_bbs_p)
+    return true;
+  return false;
 }
 
 /* Compute global backward demanded info.  */
-void
-pass_vsetvl::compute_global_backward_infos (void)
+bool
+pass_vsetvl::backward_demand_fusion (void)
 {
   /* We compute global infos by backward propagation.
      We want to have better performance in these following cases:
@@ -1848,18 +2531,19 @@ pass_vsetvl::compute_global_backward_infos (void)
 	   We backward propagate the first VSETVL into e32,mf2 so that we
 	   could be able to eliminate the second VSETVL in LCM.  */
 
+  bool changed_p = false;
   for (const bb_info *bb : crtl->ssa->reverse_bbs ())
     {
       basic_block cfg_bb = bb->cfg_bb ();
-      const auto &prop
-	= m_vector_manager->vector_block_infos[cfg_bb->index].local_dem;
+      const auto &curr_block_info
+	= m_vector_manager->vector_block_infos[cfg_bb->index];
+      const auto &prop = curr_block_info.local_dem;
 
       /* If there is nothing to propagate, just skip it.  */
       if (!prop.valid_or_dirty_p ())
 	continue;
 
-      if (!backward_propagate_worthwhile_p (
-	    cfg_bb, m_vector_manager->vector_block_infos[cfg_bb->index]))
+      if (!backward_propagate_worthwhile_p (cfg_bb, curr_block_info))
 	continue;
 
       edge e;
@@ -1867,7 +2551,6 @@ pass_vsetvl::compute_global_backward_infos (void)
       /* Backward propagate to each predecessor.  */
       FOR_EACH_EDGE (e, ei, cfg_bb->preds)
 	{
-	  rtx new_pat;
 	  auto &block_info
 	    = m_vector_manager->vector_block_infos[e->src->index];
 
@@ -1879,22 +2562,31 @@ pass_vsetvl::compute_global_backward_infos (void)
 
 	  if (block_info.reaching_out.unknown_p ())
 	    continue;
+	  else if (block_info.reaching_out.hard_empty_p ())
+	    continue;
 	  else if (block_info.reaching_out.empty_p ())
 	    {
-	      if (!can_backward_propagate_p (crtl->ssa, e->src, prop))
+	      enum fusion_type type
+		= get_backward_fusion_type (crtl->ssa->bb (e->src), prop);
+	      if (type == INVALID_FUSION)
 		continue;
 
-	      if (dominate_probability_p (e))
-		{
-		  rtx new_pat = gen_vsetvl_pat (prop.get_insn ()->rtl (), prop);
+	      block_info.reaching_out = prop;
+	      block_info.reaching_out.set_dirty (type);
 
-		  block_info.reaching_out = prop;
-		  block_info.reaching_out.set_dirty ();
-		  block_info.reaching_out.set_dirty_pat (new_pat);
-		  block_info.local_dem = block_info.reaching_out;
+	      if (prop.has_avl_reg () && !vlmax_avl_p (prop.get_avl ()))
+		{
+		  hash_set<set_info *> sets
+		    = get_all_sets (prop.get_avl_source (), true, true, true);
+		  set_info *set = get_same_bb_set (sets, e->src);
+		  if (set)
+		    block_info.reaching_out.set_avl_info (
+		      avl_info (prop.get_avl (), set));
 		}
 
-	      merge_successors (e->src, cfg_bb);
+	      block_info.local_dem = block_info.reaching_out;
+	      block_info.probability = curr_block_info.probability;
+	      changed_p = true;
 	    }
 	  else if (block_info.reaching_out.dirty_p ())
 	    {
@@ -1905,59 +2597,228 @@ pass_vsetvl::compute_global_backward_infos (void)
 		{
 		  if (block_info.reaching_out >= prop)
 		    continue;
-		  new_info = block_info.reaching_out.merge (prop, true);
+		  new_info = block_info.reaching_out.merge (prop, GLOBAL_MERGE);
+		  new_info.set_dirty (
+		    block_info.reaching_out.dirty_with_killed_avl_p ());
+		  block_info.probability += curr_block_info.probability;
 		}
 	      else
 		{
-		  if (dominate_probability_p (e))
-		    new_info = prop;
+		  if (curr_block_info.probability > block_info.probability)
+		    {
+		      enum fusion_type type
+			= get_backward_fusion_type (crtl->ssa->bb (e->src),
+						    prop);
+		      if (type == INVALID_FUSION)
+			continue;
+		      new_info = prop;
+		      new_info.set_dirty (type);
+		      block_info.probability = curr_block_info.probability;
+		    }
 		  else
 		    continue;
 		}
 
-	      rtx new_pat
-		= gen_vsetvl_pat (new_info.get_insn ()->rtl (), new_info);
-	      new_info.set_dirty ();
-	      new_info.set_dirty_pat (new_pat);
 	      block_info.local_dem = new_info;
 	      block_info.reaching_out = new_info;
+	      changed_p = true;
 	    }
 	  else
 	    {
 	      /* We not only change the info during backward propagation,
 		 but also change the VSETVL instruction.  */
 	      gcc_assert (block_info.reaching_out.valid_p ());
-	      if (!block_info.reaching_out.compatible_p (prop))
-		continue;
-	      if (block_info.reaching_out >= prop)
-		continue;
-
-	      vector_insn_info be_merged = block_info.reaching_out;
-	      if (block_info.local_dem == block_info.reaching_out)
-		be_merged = block_info.local_dem;
-	      vector_insn_info new_info = be_merged.merge (prop, true);
-
-	      rtx_insn *rinsn;
-	      if (vector_config_insn_p (new_info.get_insn ()->rtl ()))
+	      hash_set<set_info *> sets
+		= get_all_sets (prop.get_avl_source (), true, false, false);
+	      set_info *set = get_same_bb_set (sets, e->src);
+	      if (vsetvl_insn_p (block_info.reaching_out.get_insn ()->rtl ())
+		  && prop.has_avl_reg () && !vlmax_avl_p (prop.get_avl ()))
 		{
-		  rinsn = new_info.get_insn ()->rtl ();
-		  gcc_assert (vsetvl_insn_p (rinsn)
-			      && "Can't handle X0, rs1 vsetvli yet");
+		  if (!block_info.reaching_out.same_vlmax_p (prop))
+		    continue;
+		  if (block_info.reaching_out.same_vtype_p (prop))
+		    continue;
+		  if (!set)
+		    continue;
+		  if (set->insn () != block_info.reaching_out.get_insn ())
+		    continue;
 		}
 	      else
 		{
-		  gcc_assert (has_vtype_op (new_info.get_insn ()->rtl ()));
-		  rinsn = PREV_INSN (new_info.get_insn ()->rtl ());
-		  gcc_assert (vector_config_insn_p (rinsn));
+		  if (!block_info.reaching_out.compatible_p (prop))
+		    continue;
+		  if (block_info.reaching_out >= prop)
+		    continue;
 		}
-	      new_pat = gen_vsetvl_pat (rinsn, new_info);
-	      change_insn (rinsn, new_pat);
+
+	      vector_insn_info be_merged = block_info.reaching_out;
+	      if (block_info.local_dem == block_info.reaching_out)
+		be_merged = block_info.local_dem;
+	      vector_insn_info new_info = be_merged.merge (prop, GLOBAL_MERGE);
+
+	      if (curr_block_info.probability > block_info.probability)
+		block_info.probability = curr_block_info.probability;
+
+	      change_vsetvl_insn (new_info.get_insn (), new_info);
 	      if (block_info.local_dem == block_info.reaching_out)
 		block_info.local_dem = new_info;
 	      block_info.reaching_out = new_info;
+	      changed_p = true;
 	    }
 	}
     }
+  return changed_p;
+}
+
+/* Compute global forward demanded info.  */
+bool
+pass_vsetvl::forward_demand_fusion (void)
+{
+  /* Enhance the global information propagation especially
+     backward propagation miss the propagation.
+     Consider such case:
+
+			bb0
+			(TU)
+		       /   \
+		     bb1   bb2
+		     (TU)  (ANY)
+  existing edge -----> \    / (TU) <----- LCM create this edge.
+			bb3
+			(TU)
+
+     Base on the situation, LCM fails to eliminate the VSETVL instruction and
+     insert an edge from bb2 to bb3 since we can't backward propagate bb3 into
+     bb2. To avoid this confusing LCM result and non-optimal codegen, we should
+     forward propagate information from bb0 to bb2 which is friendly to LCM.  */
+  bool changed_p = false;
+  for (const bb_info *bb : crtl->ssa->bbs ())
+    {
+      basic_block cfg_bb = bb->cfg_bb ();
+      const auto &prop
+	= m_vector_manager->vector_block_infos[cfg_bb->index].reaching_out;
+
+      /* If there is nothing to propagate, just skip it.  */
+      if (!prop.valid_or_dirty_p ())
+	continue;
+
+      if (cfg_bb == ENTRY_BLOCK_PTR_FOR_FN (cfun))
+	continue;
+
+      edge e;
+      edge_iterator ei;
+      /* Forward propagate to each successor.  */
+      FOR_EACH_EDGE (e, ei, cfg_bb->succs)
+	{
+	  auto &local_dem
+	    = m_vector_manager->vector_block_infos[e->dest->index].local_dem;
+	  auto &reaching_out
+	    = m_vector_manager->vector_block_infos[e->dest->index].reaching_out;
+
+	  /* It's quite obvious, we don't need to propagate itself.  */
+	  if (e->dest->index == cfg_bb->index)
+	    continue;
+	  /* We don't propagate through critical edges.  */
+	  if (e->flags & EDGE_COMPLEX)
+	    continue;
+	  if (e->dest->index == EXIT_BLOCK_PTR_FOR_FN (cfun)->index)
+	    continue;
+
+	  /* If there is nothing to propagate, just skip it.  */
+	  if (!local_dem.valid_or_dirty_p ())
+	    continue;
+	  if (local_dem >= prop)
+	    continue;
+	  if (!local_dem.compatible_p (prop))
+	    continue;
+
+	  vector_insn_info new_info = local_dem.merge (prop, GLOBAL_MERGE);
+	  new_info.set_insn (local_dem.get_insn ());
+	  if (local_dem.dirty_p ())
+	    {
+	      gcc_assert (local_dem == reaching_out);
+	      new_info.set_dirty (local_dem.dirty_with_killed_avl_p ());
+	      local_dem = new_info;
+	      reaching_out = local_dem;
+	    }
+	  else
+	    {
+	      if (reaching_out == local_dem)
+		reaching_out = new_info;
+	      local_dem = new_info;
+	      change_vsetvl_insn (local_dem.get_insn (), new_info);
+	    }
+	  auto &prob
+	    = m_vector_manager->vector_block_infos[e->dest->index].probability;
+	  auto &curr_prob
+	    = m_vector_manager->vector_block_infos[cfg_bb->index].probability;
+	  prob = curr_prob * e->probability;
+	  changed_p = true;
+	}
+    }
+  return changed_p;
+}
+
+void
+pass_vsetvl::demand_fusion (void)
+{
+  bool changed_p = true;
+  while (changed_p)
+    {
+      changed_p = false;
+      /* To optimize the case like this:
+	 void f2 (int8_t * restrict in, int8_t * restrict out, int n, int cond)
+	   {
+	     size_t vl = 101;
+
+	     for (size_t i = 0; i < n; i++)
+	       {
+		 vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + 300, vl);
+		 __riscv_vse8_v_i8mf8 (out + i + 300, v, vl);
+	       }
+
+	     for (size_t i = 0; i < n; i++)
+	       {
+		 vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i, vl);
+		 __riscv_vse8_v_i8mf8 (out + i, v, vl);
+
+		 vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + i + 100, vl);
+		 __riscv_vse8_v_i8mf8 (out + i + 100, v2, vl);
+	       }
+	   }
+
+	  bb 0: li a5, 101 (killed avl)
+	  ...
+	  bb 1: vsetvli zero, a5, ta
+	  ...
+	  bb 2: li a5, 101 (killed avl)
+	  ...
+	  bb 3: vsetvli zero, a3, tu
+
+	We want to fuse VSEVLI instructions on bb 1 and bb 3. However, there is
+	an AVL kill instruction in bb 2 that we can't backward fuse bb 3 or
+	forward bb 1 arbitrarily. We need available information of each block to
+	help for such cases.  */
+      changed_p |= backward_demand_fusion ();
+      changed_p |= forward_demand_fusion ();
+    }
+
+  changed_p = true;
+  while (changed_p)
+    {
+      changed_p = false;
+      prune_expressions ();
+      m_vector_manager->create_bitmap_vectors ();
+      compute_local_properties ();
+      compute_available (m_vector_manager->vector_comp,
+			 m_vector_manager->vector_kill,
+			 m_vector_manager->vector_avout,
+			 m_vector_manager->vector_avin);
+      changed_p |= cleanup_illegal_dirty_blocks ();
+      m_vector_manager->free_bitmap_vectors ();
+      if (!m_vector_manager->vector_exprs.is_empty ())
+	m_vector_manager->vector_exprs.release ();
+    }
 
   if (dump_file)
     {
@@ -1970,6 +2831,34 @@ pass_vsetvl::compute_global_backward_infos (void)
     }
 }
 
+/* Cleanup illegal dirty blocks.  */
+bool
+pass_vsetvl::cleanup_illegal_dirty_blocks (void)
+{
+  bool changed_p = false;
+  for (const bb_info *bb : crtl->ssa->bbs ())
+    {
+      basic_block cfg_bb = bb->cfg_bb ();
+      const auto &prop
+	= m_vector_manager->vector_block_infos[cfg_bb->index].reaching_out;
+
+      /* If there is nothing to cleanup, just skip it.  */
+      if (!prop.valid_or_dirty_p ())
+	continue;
+
+      if (hard_empty_block_p (bb, prop))
+	{
+	  m_vector_manager->vector_block_infos[cfg_bb->index].local_dem
+	    = vector_insn_info::get_hard_empty ();
+	  m_vector_manager->vector_block_infos[cfg_bb->index].reaching_out
+	    = vector_insn_info::get_hard_empty ();
+	  changed_p = true;
+	  continue;
+	}
+    }
+  return changed_p;
+}
+
 /* Assemble the candidates expressions for LCM.  */
 void
 pass_vsetvl::prune_expressions (void)
@@ -2000,6 +2889,21 @@ pass_vsetvl::prune_expressions (void)
     }
 }
 
+/* Compute the local properties of each recorded expression.
+
+   Local properties are those that are defined by the block, irrespective of
+   other blocks.
+
+   An expression is transparent in a block if its operands are not modified
+   in the block.
+
+   An expression is computed (locally available) in a block if it is computed
+   at least once and expression would contain the same value if the
+   computation was moved to the end of the block.
+
+   An expression is locally anticipatable in a block if it is computed at
+   least once and expression would contain the same value if the computation
+   was moved to the beginning of the block.  */
 void
 pass_vsetvl::compute_local_properties (void)
 {
@@ -2022,41 +2926,87 @@ pass_vsetvl::compute_local_properties (void)
 	the block and the occurrence.  */
 
   basic_block cfg_bb;
-  FOR_EACH_BB_FN (cfg_bb, cfun)
+  for (const bb_info *bb : crtl->ssa->bbs ())
     {
-      int curr_bb_idx = cfg_bb->index;
+      unsigned int curr_bb_idx = bb->index ();
       const auto local_dem
 	= m_vector_manager->vector_block_infos[curr_bb_idx].local_dem;
       const auto reaching_out
 	= m_vector_manager->vector_block_infos[curr_bb_idx].reaching_out;
 
-      if (!local_dem.empty_p ())
+      /* Compute transparent.  */
+      for (size_t i = 0; i < m_vector_manager->vector_exprs.length (); i++)
 	{
-	  for (size_t i = 0; i < m_vector_manager->vector_exprs.length (); i++)
+	  const vector_insn_info *expr = m_vector_manager->vector_exprs[i];
+	  if (local_dem.real_dirty_p () || local_dem.valid_p ()
+	      || local_dem.unknown_p ()
+	      || has_vsetvl_killed_avl_p (bb, local_dem))
 	    bitmap_clear_bit (m_vector_manager->vector_transp[curr_bb_idx], i);
+	  /* FIXME: Here we set the block as non-transparent (killed) if there
+	     is an instruction killed the value of AVL according to the
+	     definition of Local transparent. This is true for such following
+	     case:
+
+		bb 0 (Loop label):
+		  vsetvl zero, a5, e8, mf8
+		bb 1:
+		  def a5
+		bb 2:
+		  branch bb 0 (Loop label).
+
+	     In this case, we known there is a loop bb 0->bb 1->bb 2. According
+	     to LCM definition, it is correct when we set vsetvl zero, a5, e8,
+	     mf8 as non-transparent (killed) so that LCM will not hoist outside
+	     the bb 0.
+
+	     However, such conservative configuration will forbid optimization
+	     on some unlucky case. For example:
+
+		bb 0:
+		  li a5, 101
+		bb 1:
+		  vsetvl zero, a5, e8, mf8
+		bb 2:
+		  li a5, 101
+		bb 3:
+		  vsetvl zero, a5, e8, mf8.
+	     So we also relax def a5 as transparent to gain more optimizations
+	     as long as the all real def insn of avl do not come from this
+	     block. This configuration may be still missing some optimization
+	     opportunities.  */
+	  if (find_reg_killed_by (bb, expr->get_avl ()))
+	    {
+	      hash_set<set_info *> sets
+		= get_all_sets (expr->get_avl_source (), true, false, false);
+	      if (any_set_in_bb_p (sets, bb))
+		bitmap_clear_bit (m_vector_manager->vector_transp[curr_bb_idx],
+				  i);
+	    }
 	}
 
-      if (local_dem.valid_or_dirty_p ())
-	{
-	  const insn_info *header_insn = local_dem.get_insn ();
-	  size_t header_index = m_vector_manager->get_expr_id (local_dem);
-	  if (anticipatable_occurrence_p (header_insn, local_dem))
-	    bitmap_set_bit (m_vector_manager->vector_antic[curr_bb_idx],
-			    header_index);
-	}
+      /* Compute anticipatable occurrences.  */
+      if (local_dem.valid_p () || local_dem.real_dirty_p ()
+	  || (has_vsetvl_killed_avl_p (bb, local_dem)
+	      && vlmax_avl_p (local_dem.get_avl ())))
+	if (anticipatable_occurrence_p (bb, local_dem))
+	  bitmap_set_bit (m_vector_manager->vector_antic[curr_bb_idx],
+			  m_vector_manager->get_expr_id (local_dem));
 
+      /* Compute available occurrences.  */
       if (reaching_out.valid_or_dirty_p ())
 	{
-	  const insn_info *footer_insn = reaching_out.get_insn ();
-	  size_t footer_index = m_vector_manager->get_expr_id (reaching_out);
-	  if (available_occurrence_p (footer_insn, reaching_out))
-	    bitmap_set_bit (m_vector_manager->vector_comp[curr_bb_idx],
-			    footer_index);
 	  auto_vec<size_t> available_list
 	    = m_vector_manager->get_all_available_exprs (reaching_out);
 	  for (size_t i = 0; i < available_list.length (); i++)
-	    bitmap_set_bit (m_vector_manager->vector_comp[curr_bb_idx],
-			    available_list[i]);
+	    {
+	      const vector_insn_info *expr
+		= m_vector_manager->vector_exprs[available_list[i]];
+	      if (reaching_out.real_dirty_p ()
+		  || has_vsetvl_killed_avl_p (bb, reaching_out)
+		  || available_occurrence_p (bb, *expr))
+		bitmap_set_bit (m_vector_manager->vector_comp[curr_bb_idx],
+				available_list[i]);
+	    }
 	}
     }
 
@@ -2105,15 +3055,22 @@ pass_vsetvl::compute_local_properties (void)
 
 /* Return true if VSETVL in the block can be refined as vsetvl zero,zero.  */
 bool
-pass_vsetvl::can_refine_vsetvl_p (const basic_block cfg_bb, uint8_t ratio) const
+pass_vsetvl::can_refine_vsetvl_p (const basic_block cfg_bb,
+				  const vector_insn_info &info) const
 {
   if (!m_vector_manager->all_same_ratio_p (
 	m_vector_manager->vector_avin[cfg_bb->index]))
     return false;
 
+  if (!m_vector_manager->all_same_avl_p (
+	cfg_bb, m_vector_manager->vector_avin[cfg_bb->index]))
+    return false;
+
   size_t expr_id
     = bitmap_first_set_bit (m_vector_manager->vector_avin[cfg_bb->index]);
-  if (m_vector_manager->vector_exprs[expr_id]->get_ratio () != ratio)
+  if (!m_vector_manager->vector_exprs[expr_id]->same_vlmax_p (info))
+    return false;
+  if (!m_vector_manager->vector_exprs[expr_id]->compatible_avl_p (info))
     return false;
 
   edge e;
@@ -2156,7 +3113,7 @@ pass_vsetvl::refine_vsetvls (void) const
 	continue;
 
       rtx_insn *rinsn = insn->rtl ();
-      if (!can_refine_vsetvl_p (cfg_bb, info.get_ratio ()))
+      if (!can_refine_vsetvl_p (cfg_bb, info))
 	continue;
 
       if (!vector_config_insn_p (rinsn))
@@ -2185,8 +3142,11 @@ pass_vsetvl::cleanup_vsetvls ()
 		info.set_unknown ();
 	      else
 		{
-		  insn_info *insn
-		    = m_vector_manager->vector_exprs[i]->get_insn ();
+		  const auto dem
+		    = m_vector_manager->vector_block_infos[cfg_bb->index]
+			.local_dem;
+		  gcc_assert (dem == *m_vector_manager->vector_exprs[i]);
+		  insn_info *insn = dem.get_insn ();
 		  gcc_assert (insn && insn->rtl ());
 		  rtx_insn *rinsn;
 		  if (vector_config_insn_p (insn->rtl ()))
@@ -2225,11 +3185,11 @@ pass_vsetvl::commit_vsetvls (void)
 
 	      insn_info *insn = require->get_insn ();
 	      vector_insn_info prev_info = vector_insn_info ();
-	      if (m_vector_manager->all_same_ratio_p (
-		    m_vector_manager->vector_avout[eg->src->index]))
+	      sbitmap bitdata = m_vector_manager->vector_avout[eg->src->index];
+	      if (m_vector_manager->all_same_ratio_p (bitdata)
+		  && m_vector_manager->all_same_avl_p (eg->dest, bitdata))
 		{
-		  size_t first = bitmap_first_set_bit (
-		    m_vector_manager->vector_avout[eg->src->index]);
+		  size_t first = bitmap_first_set_bit (bitdata);
 		  prev_info = *m_vector_manager->vector_exprs[first];
 		}
 
@@ -2246,18 +3206,45 @@ pass_vsetvl::commit_vsetvls (void)
 	}
     }
 
-  basic_block cfg_bb;
-  FOR_EACH_BB_FN (cfg_bb, cfun)
+  for (const bb_info *bb : crtl->ssa->bbs ())
     {
+      basic_block cfg_bb = bb->cfg_bb ();
       const auto reaching_out
 	= m_vector_manager->vector_block_infos[cfg_bb->index].reaching_out;
       if (!reaching_out.dirty_p ())
 	continue;
 
-      rtx new_pat = reaching_out.get_dirty_pat ();
-      if (can_refine_vsetvl_p (cfg_bb, reaching_out.get_ratio ()))
+      if (reaching_out.dirty_with_killed_avl_p ())
+	{
+	  if (!has_vsetvl_killed_avl_p (bb, reaching_out))
+	    continue;
+
+	  unsigned int bb_index;
+	  sbitmap_iterator sbi;
+	  sbitmap avin = m_vector_manager->vector_avin[cfg_bb->index];
+	  bool available_p = false;
+	  EXECUTE_IF_SET_IN_BITMAP (avin, 0, bb_index, sbi)
+	  {
+	    if (*m_vector_manager->vector_exprs[bb_index] >= reaching_out)
+	      {
+		available_p = true;
+		break;
+	      }
+	  }
+	  if (available_p)
+	    continue;
+	}
+
+      rtx new_pat;
+      if (can_refine_vsetvl_p (cfg_bb, reaching_out))
 	new_pat
 	  = gen_vsetvl_pat (VSETVL_VTYPE_CHANGE_ONLY, reaching_out, NULL_RTX);
+      else if (vlmax_avl_p (reaching_out.get_avl ()))
+	new_pat = gen_vsetvl_pat (VSETVL_NORMAL, reaching_out,
+				  get_vl (reaching_out.get_insn ()->rtl ()));
+      else
+	new_pat
+	  = gen_vsetvl_pat (VSETVL_DISCARD_RESULT, reaching_out, NULL_RTX);
 
       start_sequence ();
       emit_insn (new_pat);
@@ -2282,32 +3269,7 @@ pass_vsetvl::pre_vsetvl (void)
   /* Compute entity list.  */
   prune_expressions ();
 
-  /* Create the bitmap vectors.  */
-  m_vector_manager->vector_antic
-    = sbitmap_vector_alloc (last_basic_block_for_fn (cfun),
-			    m_vector_manager->vector_exprs.length ());
-  m_vector_manager->vector_transp
-    = sbitmap_vector_alloc (last_basic_block_for_fn (cfun),
-			    m_vector_manager->vector_exprs.length ());
-  m_vector_manager->vector_comp
-    = sbitmap_vector_alloc (last_basic_block_for_fn (cfun),
-			    m_vector_manager->vector_exprs.length ());
-  m_vector_manager->vector_avin
-    = sbitmap_vector_alloc (last_basic_block_for_fn (cfun),
-			    m_vector_manager->vector_exprs.length ());
-  m_vector_manager->vector_avout
-    = sbitmap_vector_alloc (last_basic_block_for_fn (cfun),
-			    m_vector_manager->vector_exprs.length ());
-  m_vector_manager->vector_kill
-    = sbitmap_vector_alloc (last_basic_block_for_fn (cfun),
-			    m_vector_manager->vector_exprs.length ());
-
-  bitmap_vector_ones (m_vector_manager->vector_transp,
-		      last_basic_block_for_fn (cfun));
-  bitmap_vector_clear (m_vector_manager->vector_antic,
-		       last_basic_block_for_fn (cfun));
-  bitmap_vector_clear (m_vector_manager->vector_comp,
-		       last_basic_block_for_fn (cfun));
+  m_vector_manager->create_bitmap_vectors ();
   compute_local_properties ();
   m_vector_manager->vector_edge_list = pre_edge_lcm_avs (
     m_vector_manager->vector_exprs.length (), m_vector_manager->vector_transp,
@@ -2369,6 +3331,115 @@ pass_vsetvl::cleanup_insns (void) const
 }
 
 void
+pass_vsetvl::propagate_avl (void) const
+{
+  /* Rebuild the RTL_SSA according to the new CFG generated by LCM.  */
+  /* Finalization of RTL_SSA.  */
+  free_dominance_info (CDI_DOMINATORS);
+  if (crtl->ssa->perform_pending_updates ())
+    cleanup_cfg (0);
+  delete crtl->ssa;
+  crtl->ssa = nullptr;
+  /* Initialization of RTL_SSA.  */
+  calculate_dominance_info (CDI_DOMINATORS);
+  df_analyze ();
+  crtl->ssa = new function_info (cfun);
+
+  hash_set<rtx_insn *> to_delete;
+  for (const bb_info *bb : crtl->ssa->bbs ())
+    {
+      for (insn_info *insn : bb->real_nondebug_insns ())
+	{
+	  if (vsetvl_discard_result_insn_p (insn->rtl ()))
+	    {
+	      rtx avl = get_avl (insn->rtl ());
+	      if (!REG_P (avl))
+		continue;
+
+	      set_info *set = find_access (insn->uses (), REGNO (avl))->def ();
+	      insn_info *def_insn = extract_single_source (set);
+	      if (!def_insn)
+		continue;
+
+	      /* Handle this case:
+		 vsetvli	a6,zero,e32,m1,ta,mu
+		 li	a5,4096
+		 add	a7,a0,a5
+		 addi	a7,a7,-96
+		 vsetvli	t1,zero,e8,mf8,ta,ma
+		 vle8.v	v24,0(a7)
+		 add	a5,a3,a5
+		 addi	a5,a5,-96
+		 vse8.v	v24,0(a5)
+		 vsetvli	zero,a6,e32,m1,tu,ma
+	      */
+	      if (vsetvl_insn_p (def_insn->rtl ()))
+		{
+		  vl_vtype_info def_info = get_vl_vtype_info (def_insn);
+		  vl_vtype_info info = get_vl_vtype_info (insn);
+		  rtx avl = get_avl (def_insn->rtl ());
+		  rtx vl = get_vl (def_insn->rtl ());
+		  if (def_info.get_ratio () == info.get_ratio ())
+		    {
+		      if (vlmax_avl_p (def_info.get_avl ()))
+			{
+			  info.set_avl_info (
+			    avl_info (def_info.get_avl (), nullptr));
+			  rtx new_pat
+			    = gen_vsetvl_pat (VSETVL_NORMAL, info, vl);
+			  validate_change (insn->rtl (),
+					   &PATTERN (insn->rtl ()), new_pat,
+					   false);
+			  continue;
+			}
+		      if (def_info.has_avl_imm () || rtx_equal_p (avl, vl))
+			{
+			  info.set_avl_info (avl_info (avl, nullptr));
+			  emit_vsetvl_insn (VSETVL_DISCARD_RESULT, EMIT_AFTER,
+					    info, NULL_RTX, insn->rtl ());
+			  if (set->single_nondebug_insn_use ())
+			    {
+			      to_delete.add (insn->rtl ());
+			      to_delete.add (def_insn->rtl ());
+			    }
+			  continue;
+			}
+		    }
+		}
+	    }
+
+	  /* Change vsetvl rd, rs1 --> vsevl zero, rs1,
+	     if rd is not used by any nondebug instructions.
+	     Even though this PASS runs after RA and it doesn't help for
+	     reduce register pressure, it can help instructions scheduling
+	     since we remove the dependencies.  */
+	  if (vsetvl_insn_p (insn->rtl ()))
+	    {
+	      rtx vl = get_vl (insn->rtl ());
+	      rtx avl = get_avl (insn->rtl ());
+	      if (vlmax_avl_p (avl))
+		continue;
+	      def_info *def = find_access (insn->defs (), REGNO (vl));
+	      set_info *set = safe_dyn_cast<set_info *> (def);
+	      gcc_assert (set);
+	      const vl_vtype_info info = get_vl_vtype_info (insn);
+	      rtx new_pat
+		= gen_vsetvl_pat (VSETVL_DISCARD_RESULT, info, NULL_RTX);
+	      if (!set->has_nondebug_insn_uses ())
+		{
+		  validate_change (insn->rtl (), &PATTERN (insn->rtl ()),
+				   new_pat, false);
+		  continue;
+		}
+	    }
+	}
+    }
+
+  for (rtx_insn *rinsn : to_delete)
+    eliminate_insn (rinsn);
+}
+
+void
 pass_vsetvl::init (void)
 {
   if (optimize > 0)
@@ -2380,6 +3451,7 @@ pass_vsetvl::init (void)
     }
 
   m_vector_manager = new vector_infos_manager ();
+  compute_probabilities ();
 
   if (dump_file)
     {
@@ -2405,6 +3477,41 @@ pass_vsetvl::done (void)
   m_vector_manager = nullptr;
 }
 
+/* Compute probability for each block.  */
+void
+pass_vsetvl::compute_probabilities (void)
+{
+  /* Don't compute it in -O0 since we don't need it.  */
+  if (!optimize)
+    return;
+  edge e;
+  edge_iterator ei;
+
+  for (const bb_info *bb : crtl->ssa->bbs ())
+    {
+      basic_block cfg_bb = bb->cfg_bb ();
+      auto &curr_prob
+	= m_vector_manager->vector_block_infos[cfg_bb->index].probability;
+      if (ENTRY_BLOCK_PTR_FOR_FN (cfun) == cfg_bb)
+	curr_prob = profile_probability::always ();
+      gcc_assert (curr_prob.initialized_p ());
+      FOR_EACH_EDGE (e, ei, cfg_bb->succs)
+	{
+	  auto &new_prob
+	    = m_vector_manager->vector_block_infos[e->dest->index].probability;
+	  if (!new_prob.initialized_p ())
+	    new_prob = curr_prob * e->probability;
+	  else if (new_prob == profile_probability::always ())
+	    continue;
+	  else
+	    new_prob += curr_prob * e->probability;
+	}
+    }
+  auto &exit_block
+    = m_vector_manager->vector_block_infos[EXIT_BLOCK_PTR_FOR_FN (cfun)->index];
+  exit_block.probability = profile_probability::always ();
+}
+
 /* Lazy vsetvl insertion for optimize > 0. */
 void
 pass_vsetvl::lazy_vsetvl (void)
@@ -2437,7 +3544,7 @@ pass_vsetvl::lazy_vsetvl (void)
   /* Phase 3 - Propagate demanded info across blocks.  */
   if (dump_file)
     fprintf (dump_file, "\nPhase 3: Demands propagation across blocks\n");
-  compute_global_backward_infos ();
+  demand_fusion ();
   if (dump_file)
     m_vector_manager->dump (dump_file);
 
@@ -2450,6 +3557,12 @@ pass_vsetvl::lazy_vsetvl (void)
   if (dump_file)
     fprintf (dump_file, "\nPhase 5: Cleanup AVL and VL operands\n");
   cleanup_insns ();
+
+  /* Phase 6 - Rebuild RTL_SSA to propagate AVL between vsetvls.  */
+  if (dump_file)
+    fprintf (dump_file,
+	     "\nPhase 6: Rebuild RTL_SSA to propagate AVL between vsetvls\n");
+  propagate_avl ();
 }
 
 /* Main entry point for this pass.  */
@@ -2459,12 +3572,10 @@ pass_vsetvl::execute (function *)
   if (n_basic_blocks_for_fn (cfun) <= 0)
     return 0;
 
-  /* The reason we have this since we didn't finish splitting yet
-     when optimize == 0. In this case, we should conservatively
-     split all instructions here to make sure we don't miss any
-     RVV instruction.  */
-  if (!optimize)
-    split_all_insns ();
+  /* The RVV instruction may change after split which is not a stable
+     instruction. We need to split it here to avoid potential issue
+     since the VSETVL PASS is insert before split PASS.  */
+  split_all_insns ();
 
   /* Early return for there is no vector instructions.  */
   if (!has_vector_insn (cfun))
diff --git a/gcc/config/riscv/riscv-vsetvl.h b/gcc/config/riscv/riscv-vsetvl.h
index dfe54d3..09df469 100644
--- a/gcc/config/riscv/riscv-vsetvl.h
+++ b/gcc/config/riscv/riscv-vsetvl.h
@@ -52,6 +52,34 @@ enum demand_type
   NUM_DEMAND
 };
 
+enum fusion_type
+{
+  INVALID_FUSION,
+  VALID_AVL_FUSION,
+  KILLED_AVL_FUSION
+};
+
+enum merge_type
+{
+  LOCAL_MERGE,
+  GLOBAL_MERGE
+};
+
+enum def_type
+{
+  REAL_SET = 1 << 0,
+  PHI_SET = 1 << 1,
+  BB_HEAD_SET = 1 << 2,
+  BB_END_SET = 1 << 3,
+  /* ??? TODO: In RTL_SSA framework, we have REAL_SET,
+     PHI_SET, BB_HEAD_SET, BB_END_SET and
+     CLOBBER_DEF def_info types. Currently,
+     we conservatively do not optimize clobber
+     def since we don't see the case that we
+     need to optimize it.  */
+  CLOBBER_DEF = 1 << 4
+};
+
 /* AVL info for RVV instruction. Most RVV instructions have AVL operand in
    implicit dependency. The AVL comparison between 2 RVV instructions is
    very important since it affects our decision whether we should insert
@@ -129,6 +157,8 @@ public:
   avl_info (rtx, rtl_ssa::set_info *);
   rtx get_value () const { return m_value; }
   rtl_ssa::set_info *get_source () const { return m_source; }
+  bool single_source_equal_p (const avl_info &) const;
+  bool multiple_source_equal_p (const avl_info &) const;
   avl_info &operator= (const avl_info &);
   bool operator== (const avl_info &) const;
   bool operator!= (const avl_info &) const;
@@ -174,6 +204,7 @@ public:
 
   rtx get_avl () const { return m_avl.get_value (); }
   const avl_info &get_avl_info () const { return m_avl; }
+  rtl_ssa::set_info *get_avl_source () const { return m_avl.get_source (); }
   void set_avl_info (const avl_info &avl) { m_avl = avl; }
   uint8_t get_sew () const { return m_sew; }
   riscv_vector::vlmul_type get_vlmul () const { return m_vlmul; }
@@ -195,11 +226,31 @@ private:
     VALID,
     UNKNOWN,
     EMPTY,
+    /* The empty block can not be polluted as dirty.  */
+    HARD_EMPTY,
 
     /* The block is polluted as containing VSETVL instruction during dem
        backward propagation to gain better LCM optimization even though
        such VSETVL instruction is not really emit yet during this time.  */
-    DIRTY
+    DIRTY,
+    /* The block is polluted with killed AVL.
+       We will backward propagate such case:
+	 bb 0: def a5, 55 (empty).
+	 ...
+	 bb 1: vsetvli zero, a5.
+	 ...
+	 bb 2: empty.
+	 ...
+	 bb 3: def a3, 55 (empty).
+	 ...
+	 bb 4: vsetvli zero, a3.
+
+       To elide vsetvli in bb 4, we need to backward pollute bb 3 and bb 2
+       as DIRTY block as long as there is a block def AVL which has the same
+       source with AVL in bb 4. Such polluted block, we call it as
+       DIRTY_WITH_KILLED_AVL
+    */
+    DIRTY_WITH_KILLED_AVL
   };
 
   enum state_type m_state;
@@ -220,13 +271,6 @@ private:
      (with AVL included) before vmv.x.s, but vmv.x.s is not the INSN holding the
      definition of AVL.  */
   rtl_ssa::insn_info *m_insn;
-  /* Save instruction pattern for Dirty block.
-     Since empty block may be polluted as a dirty block during dem backward
-     propagation (phase 3) which is intending to cheat LCM there is a VSETVL
-     instruction here to gain better LCM optimization. Such instruction is not
-     emit yet, we save this here and then emit it in the 4th phase if it is
-     necessary.  */
-  rtx m_dirty_pat;
 
   /* Parse the instruction to get VL/VTYPE information and demanding
    * information.  */
@@ -234,18 +278,19 @@ private:
      Since RTL_SSA can not be enabled when optimize == 0, we don't initialize
      the m_insn.  */
   void parse_insn (rtx_insn *);
-  /* This is only called by lazy_vsetvl subroutine when optimize > 0.
-     We use RTL_SSA framework to initialize the insn_info.  */
-  void parse_insn (rtl_ssa::insn_info *);
 
   friend class vector_infos_manager;
 
 public:
   vector_insn_info ()
     : vl_vtype_info (), m_state (UNINITIALIZED), m_demands{false},
-      m_insn (nullptr), m_dirty_pat (NULL_RTX)
+      m_insn (nullptr)
   {}
 
+  /* This is only called by lazy_vsetvl subroutine when optimize > 0.
+     We use RTL_SSA framework to initialize the insn_info.  */
+  void parse_insn (rtl_ssa::insn_info *);
+
   bool operator> (const vector_insn_info &) const;
   bool operator>= (const vector_insn_info &) const;
   bool operator== (const vector_insn_info &) const;
@@ -253,12 +298,23 @@ public:
   bool uninit_p () const { return m_state == UNINITIALIZED; }
   bool valid_p () const { return m_state == VALID; }
   bool unknown_p () const { return m_state == UNKNOWN; }
-  bool empty_p () const { return m_state == EMPTY; }
-  bool dirty_p () const { return m_state == DIRTY; }
+  bool empty_p () const { return m_state == EMPTY || m_state == HARD_EMPTY; }
+  bool hard_empty_p () const { return m_state == HARD_EMPTY; }
+  bool dirty_p () const
+  {
+    return m_state == DIRTY || m_state == DIRTY_WITH_KILLED_AVL;
+  }
+  bool dirty_with_killed_avl_p () const
+  {
+    return m_state == DIRTY_WITH_KILLED_AVL;
+  }
+  bool real_dirty_p () const { return m_state == DIRTY; }
   bool valid_or_dirty_p () const
   {
-    return m_state == VALID || m_state == DIRTY;
+    return m_state == VALID || m_state == DIRTY
+	   || m_state == DIRTY_WITH_KILLED_AVL;
   }
+  bool available_p (const vector_insn_info &) const;
 
   static vector_insn_info get_unknown ()
   {
@@ -267,11 +323,32 @@ public:
     return info;
   }
 
+  static vector_insn_info get_hard_empty ()
+  {
+    vector_insn_info info;
+    info.set_hard_empty ();
+    return info;
+  }
+
   void set_valid () { m_state = VALID; }
   void set_unknown () { m_state = UNKNOWN; }
   void set_empty () { m_state = EMPTY; }
-  void set_dirty () { m_state = DIRTY; }
-  void set_dirty_pat (rtx pat) { m_dirty_pat = pat; }
+  void set_hard_empty () { m_state = HARD_EMPTY; }
+  void set_dirty (enum fusion_type type)
+  {
+    gcc_assert (type == VALID_AVL_FUSION || type == KILLED_AVL_FUSION);
+    if (type == VALID_AVL_FUSION)
+      m_state = DIRTY;
+    else
+      m_state = DIRTY_WITH_KILLED_AVL;
+  }
+  void set_dirty (bool dirty_with_killed_avl_p)
+  {
+    if (dirty_with_killed_avl_p)
+      m_state = DIRTY_WITH_KILLED_AVL;
+    else
+      m_state = DIRTY;
+  }
   void set_insn (rtl_ssa::insn_info *insn) { m_insn = insn; }
 
   bool demand_p (enum demand_type type) const { return m_demands[type]; }
@@ -281,12 +358,12 @@ public:
 
   bool compatible_p (const vector_insn_info &) const;
   bool compatible_avl_p (const vl_vtype_info &) const;
+  bool compatible_avl_p (const avl_info &) const;
   bool compatible_vtype_p (const vl_vtype_info &) const;
   bool compatible_p (const vl_vtype_info &) const;
-  vector_insn_info merge (const vector_insn_info &, bool) const;
+  vector_insn_info merge (const vector_insn_info &, enum merge_type) const;
 
   rtl_ssa::insn_info *get_insn () const { return m_insn; }
-  rtx get_dirty_pat () const { return m_dirty_pat; }
 
   void dump (FILE *) const;
 };
@@ -299,6 +376,9 @@ struct vector_block_info
   /* The reaching_out vector insn_info of the block.  */
   vector_insn_info reaching_out;
 
+  /* The static execute probability of the demand info.  */
+  profile_probability probability;
+
   vector_block_info () = default;
 };
 
@@ -333,10 +413,15 @@ public:
   /* Get all relaxer expression id for corresponding vector info.  */
   auto_vec<size_t> get_all_available_exprs (const vector_insn_info &) const;
 
+  /* Return true if all expression set in bitmap are same AVL.  */
+  bool all_same_avl_p (const basic_block, sbitmap) const;
+
   /* Return true if all expression set in bitmap are same ratio.  */
   bool all_same_ratio_p (sbitmap) const;
 
   void release (void);
+  void create_bitmap_vectors (void);
+  void free_bitmap_vectors (void);
 
   void dump (FILE *) const;
 };
diff --git a/gcc/config/riscv/vector-iterators.md b/gcc/config/riscv/vector-iterators.md
index 840cd8d..2ac75b3 100644
--- a/gcc/config/riscv/vector-iterators.md
+++ b/gcc/config/riscv/vector-iterators.md
@@ -18,11 +18,24 @@
 ;; along with GCC; see the file COPYING3.  If not see
 ;; <http://www.gnu.org/licenses/>.
 
+(define_c_enum "unspec" [
+  UNSPEC_VSETVL
+  UNSPEC_VUNDEF
+  UNSPEC_VPREDICATE
+  UNSPEC_VLMAX
+  UNSPEC_STRIDED
+
+  ;; It's used to specify ordered/unorderd operation.
+  UNSPEC_ORDERED
+  UNSPEC_UNORDERED
+])
+
 (define_mode_iterator V [
   VNx1QI VNx2QI VNx4QI VNx8QI VNx16QI VNx32QI (VNx64QI "TARGET_MIN_VLEN > 32")
   VNx1HI VNx2HI VNx4HI VNx8HI VNx16HI (VNx32HI "TARGET_MIN_VLEN > 32")
   VNx1SI VNx2SI VNx4SI VNx8SI (VNx16SI "TARGET_MIN_VLEN > 32")
-  VNx1DI VNx2DI VNx4DI (VNx8DI "TARGET_MIN_VLEN > 32")
+  (VNx1DI "TARGET_MIN_VLEN > 32") (VNx2DI "TARGET_MIN_VLEN > 32")
+  (VNx4DI "TARGET_MIN_VLEN > 32") (VNx8DI "TARGET_MIN_VLEN > 32")
   (VNx1SF "TARGET_VECTOR_ELEN_FP_32")
   (VNx2SF "TARGET_VECTOR_ELEN_FP_32")
   (VNx4SF "TARGET_VECTOR_ELEN_FP_32")
@@ -34,11 +47,81 @@
   (VNx8DF "TARGET_VECTOR_ELEN_FP_64")
 ])
 
+(define_mode_iterator VNX1_QHSD [
+  VNx1QI VNx1HI VNx1SI
+  (VNx1DI "TARGET_MIN_VLEN > 32")
+  (VNx1SF "TARGET_VECTOR_ELEN_FP_32")
+  (VNx1DF "TARGET_VECTOR_ELEN_FP_64")
+])
+
+(define_mode_iterator VNX2_QHSD [
+  VNx2QI VNx2HI VNx2SI
+  (VNx2DI "TARGET_MIN_VLEN > 32")
+  (VNx2SF "TARGET_VECTOR_ELEN_FP_32")
+  (VNx2DF "TARGET_VECTOR_ELEN_FP_64")
+])
+
+(define_mode_iterator VNX4_QHSD [
+  VNx4QI VNx4HI VNx4SI
+  (VNx4DI "TARGET_MIN_VLEN > 32")
+  (VNx4SF "TARGET_VECTOR_ELEN_FP_32")
+  (VNx4DF "TARGET_VECTOR_ELEN_FP_64")
+])
+
+(define_mode_iterator VNX8_QHSD [
+  VNx8QI VNx8HI VNx8SI
+  (VNx8DI "TARGET_MIN_VLEN > 32")
+  (VNx8SF "TARGET_VECTOR_ELEN_FP_32")
+  (VNx8DF "TARGET_VECTOR_ELEN_FP_64")
+])
+
+(define_mode_iterator VNX16_QHS [
+  VNx16QI VNx16HI (VNx16SI "TARGET_MIN_VLEN > 32")
+  (VNx16SF "TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN > 32")
+])
+
+(define_mode_iterator VNX32_QH [
+  VNx32QI (VNx32HI "TARGET_MIN_VLEN > 32")
+])
+
+(define_mode_iterator VNX64_Q [
+  (VNx64QI "TARGET_MIN_VLEN > 32")
+])
+
+(define_mode_iterator VNX1_QHSDI [
+  VNx1QI VNx1HI VNx1SI
+  (VNx1DI "TARGET_64BIT && TARGET_MIN_VLEN > 32")
+])
+
+(define_mode_iterator VNX2_QHSDI [
+  VNx2QI VNx2HI VNx2SI
+  (VNx2DI "TARGET_64BIT && TARGET_MIN_VLEN > 32")
+])
+
+(define_mode_iterator VNX4_QHSDI [
+  VNx4QI VNx4HI VNx4SI
+  (VNx4DI "TARGET_64BIT && TARGET_MIN_VLEN > 32")
+])
+
+(define_mode_iterator VNX8_QHSDI [
+  VNx8QI VNx8HI VNx8SI
+  (VNx8DI "TARGET_64BIT && TARGET_MIN_VLEN > 32")
+])
+
+(define_mode_iterator VNX16_QHSI [
+  VNx16QI VNx16HI (VNx16SI "TARGET_MIN_VLEN > 32")
+])
+
+(define_mode_iterator VNX32_QHI [
+  VNx32QI (VNx32HI "TARGET_MIN_VLEN > 32")
+])
+
 (define_mode_iterator V_WHOLE [
   (VNx4QI "TARGET_MIN_VLEN == 32") VNx8QI VNx16QI VNx32QI (VNx64QI "TARGET_MIN_VLEN > 32")
   (VNx2HI "TARGET_MIN_VLEN == 32") VNx4HI VNx8HI VNx16HI (VNx32HI "TARGET_MIN_VLEN > 32")
   (VNx1SI "TARGET_MIN_VLEN == 32") VNx2SI VNx4SI VNx8SI (VNx16SI "TARGET_MIN_VLEN > 32")
-  VNx1DI VNx2DI VNx4DI (VNx8DI "TARGET_MIN_VLEN > 32")
+  (VNx1DI "TARGET_MIN_VLEN > 32") (VNx2DI "TARGET_MIN_VLEN > 32")
+  (VNx4DI "TARGET_MIN_VLEN > 32") (VNx8DI "TARGET_MIN_VLEN > 32")
   (VNx1SF "TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN == 32")
   (VNx2SF "TARGET_VECTOR_ELEN_FP_32")
   (VNx4SF "TARGET_VECTOR_ELEN_FP_32")
@@ -88,3 +171,9 @@
   (VNx1SF "32") (VNx2SF "32") (VNx4SF "32") (VNx8SF "32") (VNx16SF "32")
   (VNx1DF "64") (VNx2DF "64") (VNx4DF "64") (VNx8DF "64")
 ])
+
+(define_int_iterator ORDER [UNSPEC_ORDERED UNSPEC_UNORDERED])
+
+(define_int_attr order [
+  (UNSPEC_ORDERED "o") (UNSPEC_UNORDERED "u")
+])
diff --git a/gcc/config/riscv/vector.md b/gcc/config/riscv/vector.md
index f2b18c1..403d2f6 100644
--- a/gcc/config/riscv/vector.md
+++ b/gcc/config/riscv/vector.md
@@ -28,13 +28,6 @@
 
 (include "vector-iterators.md")
 
-(define_c_enum "unspec" [
-  UNSPEC_VSETVL
-  UNSPEC_VUNDEF
-  UNSPEC_VPREDICATE
-  UNSPEC_VLMAX
-])
-
 (define_constants [
    (INVALID_ATTRIBUTE            255)
 ])
@@ -95,13 +88,7 @@
 	 (const_int 32)
 	 (eq_attr "mode" "VNx1DI,VNx2DI,VNx4DI,VNx8DI,\
 			  VNx1DF,VNx2DF,VNx4DF,VNx8DF")
-	 (const_int 64)
-
-	 (eq_attr "type" "vsetvl")
-	 (if_then_else (eq_attr "INSN_CODE (curr_insn) == CODE_FOR_vsetvldi
-				 || INSN_CODE (curr_insn) == CODE_FOR_vsetvlsi")
-		       (symbol_ref "INTVAL (operands[2])")
-		       (const_int INVALID_ATTRIBUTE))]
+	 (const_int 64)]
 	(const_int INVALID_ATTRIBUTE)))
 
 ;; Ditto to LMUL.
@@ -149,17 +136,12 @@
 	 (eq_attr "mode" "VNx4DI,VNx4DF")
 	   (symbol_ref "riscv_vector::get_vlmul(E_VNx4DImode)")
 	 (eq_attr "mode" "VNx8DI,VNx8DF")
-	   (symbol_ref "riscv_vector::get_vlmul(E_VNx8DImode)")
-	 (eq_attr "type" "vsetvl")
-	 (if_then_else (eq_attr "INSN_CODE (curr_insn) == CODE_FOR_vsetvldi
-				 || INSN_CODE (curr_insn) == CODE_FOR_vsetvlsi")
-		       (symbol_ref "INTVAL (operands[3])")
-		       (const_int INVALID_ATTRIBUTE))]
+	   (symbol_ref "riscv_vector::get_vlmul(E_VNx8DImode)")]
 	(const_int INVALID_ATTRIBUTE)))
 
 ;; It is valid for instruction that require sew/lmul ratio.
 (define_attr "ratio" ""
-  (cond [(eq_attr "type" "vimov,vfmov")
+  (cond [(eq_attr "type" "vimov,vfmov,vldux,vldox,vstux,vstox")
 	   (const_int INVALID_ATTRIBUTE)
 	 (eq_attr "mode" "VNx1QI,VNx1BI")
 	   (symbol_ref "riscv_vector::get_ratio(E_VNx1QImode)")
@@ -209,53 +191,75 @@
 
 ;; The index of operand[] to get the merge op.
 (define_attr "merge_op_idx" ""
-	(cond [(eq_attr "type" "vlde,vste,vimov,vfmov,vldm,vstm,vlds,vmalu")
+	(cond [(eq_attr "type" "vlde,vimov,vfmov,vldm,vlds,vmalu,vldux,vldox")
 	 (const_int 2)]
 	(const_int INVALID_ATTRIBUTE)))
 
 ;; The index of operand[] to get the avl op.
 (define_attr "vl_op_idx" ""
-	(cond [(eq_attr "type" "vlde,vste,vimov,vfmov,vldm,vstm,vlds,vmalu")
-	 (const_int 4)]
-	(const_int INVALID_ATTRIBUTE)))
+  (cond [(eq_attr "type" "vlde,vste,vimov,vfmov,vldm,vstm,vmalu,vsts,vstux,vstox")
+	   (const_int 4)
 
-;; The index of operand[] to get the tail policy op.
-(define_attr "tail_policy_op_idx" ""
-  (cond [(eq_attr "type" "vlde,vste,vimov,vfmov,vlds")
-	 (const_int 5)]
-	(const_int INVALID_ATTRIBUTE)))
-
-;; The index of operand[] to get the mask policy op.
-(define_attr "mask_policy_op_idx" ""
-  (cond [(eq_attr "type" "vlde,vste,vlds")
-	 (const_int 6)]
-	(const_int INVALID_ATTRIBUTE)))
+	 ;; If operands[3] of "vlds" is not vector mode, it is pred_broadcast.
+	 ;; wheras it is pred_strided_load if operands[3] is vector mode.
+         (eq_attr "type" "vlds")
+	   (if_then_else (match_test "VECTOR_MODE_P (GET_MODE (operands[3]))")
+             (const_int 5)
+             (const_int 4))
 
-;; The index of operand[] to get the mask policy op.
-(define_attr "avl_type_op_idx" ""
-  (cond [(eq_attr "type" "vlde,vlde,vste,vimov,vimov,vimov,vfmov,vlds,vlds")
-	 (const_int 7)
-	 (eq_attr "type" "vldm,vstm,vimov,vmalu,vmalu")
-	 (const_int 5)]
-	(const_int INVALID_ATTRIBUTE)))
+	 (eq_attr "type" "vldux,vldox")
+	   (const_int 5)]
+  (const_int INVALID_ATTRIBUTE)))
 
 ;; The tail policy op value.
 (define_attr "ta" ""
-  (cond [(eq_attr "type" "vlde,vimov,vfmov,vlds")
-	   (symbol_ref "riscv_vector::get_ta(operands[5])")]
+  (cond [(eq_attr "type" "vlde,vimov,vfmov")
+	   (symbol_ref "riscv_vector::get_ta(operands[5])")
+
+	 ;; If operands[3] of "vlds" is not vector mode, it is pred_broadcast.
+	 ;; wheras it is pred_strided_load if operands[3] is vector mode.
+	 (eq_attr "type" "vlds")
+	   (if_then_else (match_test "VECTOR_MODE_P (GET_MODE (operands[3]))")
+	     (symbol_ref "riscv_vector::get_ta(operands[6])")
+	     (symbol_ref "riscv_vector::get_ta(operands[5])"))
+
+	 (eq_attr "type" "vldux,vldox")
+	   (symbol_ref "riscv_vector::get_ta(operands[6])")]
 	(const_int INVALID_ATTRIBUTE)))
 
 ;; The mask policy op value.
 (define_attr "ma" ""
-  (cond [(eq_attr "type" "vlde,vlds")
-	   (symbol_ref "riscv_vector::get_ma(operands[6])")]
+  (cond [(eq_attr "type" "vlde")
+	   (symbol_ref "riscv_vector::get_ma(operands[6])")
+
+	 ;; If operands[3] of "vlds" is not vector mode, it is pred_broadcast.
+	 ;; wheras it is pred_strided_load if operands[3] is vector mode.
+	 (eq_attr "type" "vlds")
+	   (if_then_else (match_test "VECTOR_MODE_P (GET_MODE (operands[3]))")
+	     (symbol_ref "riscv_vector::get_ma(operands[7])")
+	     (symbol_ref "riscv_vector::get_ma(operands[6])"))
+
+	 (eq_attr "type" "vldux,vldox")
+	   (symbol_ref "riscv_vector::get_ma(operands[7])")]
 	(const_int INVALID_ATTRIBUTE)))
 
 ;; The avl type value.
 (define_attr "avl_type" ""
-  (cond [(eq_attr "type" "vlde,vlde,vste,vimov,vimov,vimov,vfmov,vlds,vlds")
+  (cond [(eq_attr "type" "vlde,vlde,vste,vimov,vimov,vimov,vfmov")
 	   (symbol_ref "INTVAL (operands[7])")
 	 (eq_attr "type" "vldm,vstm,vimov,vmalu,vmalu")
+	   (symbol_ref "INTVAL (operands[5])")
+
+	 ;; If operands[3] of "vlds" is not vector mode, it is pred_broadcast.
+	 ;; wheras it is pred_strided_load if operands[3] is vector mode.
+	 (eq_attr "type" "vlds")
+	   (if_then_else (match_test "VECTOR_MODE_P (GET_MODE (operands[3]))")
+	     (const_int INVALID_ATTRIBUTE)
+	     (symbol_ref "INTVAL (operands[7])"))
+
+	 (eq_attr "type" "vldux,vldox")
+	   (symbol_ref "INTVAL (operands[8])")
+	 (eq_attr "type" "vstux,vstox")
 	   (symbol_ref "INTVAL (operands[5])")]
 	(const_int INVALID_ATTRIBUTE)))
 
@@ -551,7 +555,11 @@
   "TARGET_VECTOR"
   "vset%i1vli\t%0,%1,e%2,%m3,t%p4,m%p5"
   [(set_attr "type" "vsetvl")
-   (set_attr "mode" "<MODE>")])
+   (set_attr "mode" "<MODE>")
+   (set (attr "sew") (symbol_ref "INTVAL (operands[2])"))
+   (set (attr "vlmul") (symbol_ref "INTVAL (operands[3])"))
+   (set (attr "ta") (symbol_ref "INTVAL (operands[4])"))
+   (set (attr "ma") (symbol_ref "INTVAL (operands[5])"))])
 
 ;; vsetvl zero,zero,vtype instruction.
 ;; This pattern has no side effects and does not set X0 register.
@@ -581,9 +589,13 @@
 		    (match_operand 3 "const_int_operand" "i")
 		    (match_operand 4 "const_int_operand" "i")] UNSPEC_VSETVL))]
   "TARGET_VECTOR"
-  "vsetvli\tzero,%0,e%1,%m2,t%p3,m%p4"
+  "vset%i0vli\tzero,%0,e%1,%m2,t%p3,m%p4"
   [(set_attr "type" "vsetvl")
-   (set_attr "mode" "<MODE>")])
+   (set_attr "mode" "<MODE>")
+   (set (attr "sew") (symbol_ref "INTVAL (operands[1])"))
+   (set (attr "vlmul") (symbol_ref "INTVAL (operands[2])"))
+   (set (attr "ta") (symbol_ref "INTVAL (operands[3])"))
+   (set (attr "ma") (symbol_ref "INTVAL (operands[4])"))])
 
 ;; It's emit by vsetvl/vsetvlmax intrinsics with no side effects.
 ;; Since we have many optmization passes from "expand" to "reload_completed",
@@ -656,22 +668,23 @@
 ;;    2. (const_vector:VNx1SF repeat [
 ;;                (const_double:SF 0.0 [0x0.0p+0])]).
 (define_insn_and_split "@pred_mov<mode>"
-  [(set (match_operand:V 0 "nonimmediate_operand"          "=vd,    vr,     m,    vr,    vr")
-	(if_then_else:V
-	  (unspec:<VM>
-	    [(match_operand:<VM> 1 "vector_mask_operand" "vmWc1, vmWc1, vmWc1,   Wc1,   Wc1")
-	     (match_operand 4 "vector_length_operand"    "   rK,    rK,    rK,    rK,    rK")
-	     (match_operand 5 "const_int_operand"        "    i,     i,     i,     i,     i")
-	     (match_operand 6 "const_int_operand"        "    i,     i,     i,     i,     i")
-	     (match_operand 7 "const_int_operand"        "    i,     i,     i,     i,     i")
-	     (reg:SI VL_REGNUM)
-	     (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE)
-	  (match_operand:V 3 "vector_move_operand"       "    m,     m,    vr,    vr, viWc0")
-	  (match_operand:V 2 "vector_merge_operand"      "    0,    vu,   vu0,   vu0,   vu0")))]
+  [(set (match_operand:V 0 "nonimmediate_operand"      "=vr,    vr,    vd,     m,    vr,    vr")
+    (if_then_else:V
+      (unspec:<VM>
+        [(match_operand:<VM> 1 "vector_mask_operand" "vmWc1,   Wc1,    vm, vmWc1,   Wc1,   Wc1")
+         (match_operand 4 "vector_length_operand"    "   rK,    rK,    rK,    rK,    rK,    rK")
+         (match_operand 5 "const_int_operand"        "    i,     i,     i,     i,     i,     i")
+         (match_operand 6 "const_int_operand"        "    i,     i,     i,     i,     i,     i")
+         (match_operand 7 "const_int_operand"        "    i,     i,     i,     i,     i,     i")
+         (reg:SI VL_REGNUM)
+         (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE)
+      (match_operand:V 3 "vector_move_operand"       "    m,     m,     m,    vr,    vr, viWc0")
+      (match_operand:V 2 "vector_merge_operand"      "    0,    vu,    vu,    vu,   vu0,   vu0")))]
   "TARGET_VECTOR"
   "@
    vle<sew>.v\t%0,%3%p1
-   vle<sew>.v\t%0,%3%p1
+   vle<sew>.v\t%0,%3
+   vle<sew>.v\t%0,%3,%1.t
    vse<sew>.v\t%3,%0%p1
    vmv.v.v\t%0,%3
    vmv.v.i\t%0,%v3"
@@ -680,9 +693,28 @@
    && satisfies_constraint_vu (operands[2])"
   [(set (match_dup 0) (match_dup 3))]
   ""
-  [(set_attr "type" "vlde,vlde,vste,vimov,vimov")
+  [(set_attr "type" "vlde,vlde,vlde,vste,vimov,vimov")
    (set_attr "mode" "<MODE>")])
 
+;; Dedicated pattern for vse.v instruction since we can't reuse pred_mov pattern to include
+;; memory operand as input which will produce inferior codegen.
+(define_insn "@pred_store<mode>"
+  [(set (match_operand:V 0 "memory_operand"                 "+m")
+	(if_then_else:V
+	  (unspec:<VM>
+	    [(match_operand:<VM> 1 "vector_mask_operand" "vmWc1")
+	     (match_operand 3 "vector_length_operand"    "   rK")
+	     (reg:SI VL_REGNUM)
+	     (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE)
+	  (match_operand:V 2 "register_operand"         "    vr")
+	  (match_dup 0)))]
+  "TARGET_VECTOR"
+  "vse<sew>.v\t%2,%0%p1"
+  [(set_attr "type" "vste")
+   (set_attr "mode" "<MODE>")
+   (set (attr "avl_type") (symbol_ref "riscv_vector::NONVLMAX"))
+   (set_attr "vl_op_idx" "3")])
+
 ;; vlm.v/vsm.v/vmclr.m/vmset.m.
 ;; constraint alternative 0 match vlm.v.
 ;; constraint alternative 1 match vsm.v.
@@ -698,7 +730,7 @@
 	     (reg:SI VL_REGNUM)
 	     (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE)
 	  (match_operand:VB 3 "vector_move_operand"      "  m,  vr,  vr, Wc0, Wc1")
-	  (match_operand:VB 2 "vector_merge_operand"     " vu, vu0,  vu,  vu,  vu")))]
+	  (match_operand:VB 2 "vector_merge_operand"     " vu,  vu,  vu,  vu,  vu")))]
   "TARGET_VECTOR"
   "@
    vlm.v\t%0,%3
@@ -713,6 +745,25 @@
   [(set_attr "type" "vldm,vstm,vimov,vmalu,vmalu")
    (set_attr "mode" "<MODE>")])
 
+;; Dedicated pattern for vsm.v instruction since we can't reuse pred_mov pattern to include
+;; memory operand as input which will produce inferior codegen.
+(define_insn "@pred_store<mode>"
+  [(set (match_operand:VB 0 "memory_operand"            "+m")
+	(if_then_else:VB
+	  (unspec:VB
+	    [(match_operand:VB 1 "vector_mask_operand" "Wc1")
+	     (match_operand 3 "vector_length_operand"  " rK")
+	     (reg:SI VL_REGNUM)
+	     (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE)
+	  (match_operand:VB 2 "register_operand"       " vr")
+	  (match_dup 0)))]
+  "TARGET_VECTOR"
+  "vsm.v\t%2,%0"
+  [(set_attr "type" "vstm")
+   (set_attr "mode" "<MODE>")
+   (set (attr "avl_type") (symbol_ref "riscv_vector::NONVLMAX"))
+   (set_attr "vl_op_idx" "3")])
+
 ;; -------------------------------------------------------------------------------
 ;; ---- Predicated Broadcast
 ;; -------------------------------------------------------------------------------
@@ -744,3 +795,319 @@
    vlse<sew>.v\t%0,%3,zero"
   [(set_attr "type" "vimov,vfmov,vlds,vlds")
    (set_attr "mode" "<MODE>")])
+
+;; -------------------------------------------------------------------------------
+;; ---- Predicated Strided loads/stores
+;; -------------------------------------------------------------------------------
+;; Includes:
+;; - 7.5. Vector Strided Instructions
+;; -------------------------------------------------------------------------------
+
+(define_insn "@pred_strided_load<mode>"
+  [(set (match_operand:V 0 "register_operand"              "=vr,    vr,    vd")
+	(if_then_else:V
+	  (unspec:<VM>
+	    [(match_operand:<VM> 1 "vector_mask_operand" "vmWc1,   Wc1,    vm")
+	     (match_operand 5 "vector_length_operand"    "   rK,    rK,    rK")
+	     (match_operand 6 "const_int_operand"        "    i,     i,     i")
+	     (match_operand 7 "const_int_operand"        "    i,     i,     i")
+	     (reg:SI VL_REGNUM)
+	     (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE)
+	  (unspec:V
+	    [(match_operand:V 3 "memory_operand"         "    m,     m,     m")
+	     (match_operand 4 "pmode_reg_or_0_operand"   "   rJ,    rJ,    rJ")] UNSPEC_STRIDED)
+	  (match_operand:V 2 "vector_merge_operand"      "    0,    vu,    vu")))]
+  "TARGET_VECTOR"
+  "vlse<sew>.v\t%0,%3,%z4%p1"
+  [(set_attr "type" "vlds")
+   (set_attr "mode" "<MODE>")])
+
+(define_insn "@pred_strided_store<mode>"
+  [(set (match_operand:V 0 "memory_operand"                 "+m")
+	(if_then_else:V
+	  (unspec:<VM>
+	    [(match_operand:<VM> 1 "vector_mask_operand" "vmWc1")
+	     (match_operand 4 "vector_length_operand"    "   rK")
+	     (reg:SI VL_REGNUM)
+	     (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE)
+	  (unspec:V
+	    [(match_operand 2 "pmode_reg_or_0_operand"   "   rJ")
+	     (match_operand:V 3 "register_operand"       "   vr")] UNSPEC_STRIDED)
+	  (match_dup 0)))]
+  "TARGET_VECTOR"
+  "vsse<sew>.v\t%3,%0,%z2%p1"
+  [(set_attr "type" "vsts")
+   (set_attr "mode" "<MODE>")])
+
+;; -------------------------------------------------------------------------------
+;; ---- Predicated indexed loads/stores
+;; -------------------------------------------------------------------------------
+;; Includes:
+;; - 7.6. Vector Indexed Instructions
+;; -------------------------------------------------------------------------------
+
+(define_insn "@pred_indexed_<order>load<VNX1_QHSD:mode><VNX1_QHSDI:mode>"
+  [(set (match_operand:VNX1_QHSD 0 "register_operand"      "=&vr")
+	(if_then_else:VNX1_QHSD
+	  (unspec:<VM>
+	    [(match_operand:<VM> 1 "vector_mask_operand"  "vmWc1")
+	     (match_operand 5 "vector_length_operand"     "   rK")
+	     (match_operand 6 "const_int_operand"         "    i")
+	     (match_operand 7 "const_int_operand"         "    i")
+	     (match_operand 8 "const_int_operand"         "    i")
+	     (reg:SI VL_REGNUM)
+	     (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE)
+	  (unspec:VNX1_QHSD
+	    [(match_operand 3 "pmode_register_operand"    "    r")
+	     (mem:BLK (scratch))
+	     (match_operand:VNX1_QHSDI 4 "register_operand" " vr")] ORDER)
+	  (match_operand:VNX1_QHSD 2 "vector_merge_operand" "0vu")))]
+  "TARGET_VECTOR"
+  "vl<order>xei<VNX1_QHSDI:sew>.v\t%0,(%3),%4%p1"
+  [(set_attr "type" "vld<order>x")
+   (set_attr "mode" "<VNX1_QHSD:MODE>")])
+
+(define_insn "@pred_indexed_<order>store<VNX1_QHSD:mode><VNX1_QHSDI:mode>"
+  [(set (mem:BLK (scratch))
+	(unspec:BLK
+	  [(unspec:<VM>
+	    [(match_operand:<VM> 0 "vector_mask_operand" "vmWc1")
+	     (match_operand 4 "vector_length_operand"    "   rK")
+	     (match_operand 5 "const_int_operand"        "    i")
+	     (reg:SI VL_REGNUM)
+	     (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE)
+	   (match_operand 1 "pmode_register_operand"      "   r")
+	   (match_operand:VNX1_QHSDI 2 "register_operand" "  vr")
+	   (match_operand:VNX1_QHSD 3 "register_operand"  "  vr")] ORDER))]
+  "TARGET_VECTOR"
+  "vs<order>xei<VNX1_QHSDI:sew>.v\t%3,(%1),%2%p0"
+  [(set_attr "type" "vst<order>x")
+   (set_attr "mode" "<VNX1_QHSD:MODE>")])
+
+(define_insn "@pred_indexed_<order>load<VNX2_QHSD:mode><VNX2_QHSDI:mode>"
+  [(set (match_operand:VNX2_QHSD 0 "register_operand"      "=&vr")
+	(if_then_else:VNX2_QHSD
+	  (unspec:<VM>
+	    [(match_operand:<VM> 1 "vector_mask_operand"  "vmWc1")
+	     (match_operand 5 "vector_length_operand"     "   rK")
+	     (match_operand 6 "const_int_operand"         "    i")
+	     (match_operand 7 "const_int_operand"         "    i")
+	     (match_operand 8 "const_int_operand"         "    i")
+	     (reg:SI VL_REGNUM)
+	     (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE)
+	  (unspec:VNX2_QHSD
+	    [(match_operand 3 "pmode_register_operand"    "    r")
+	     (mem:BLK (scratch))
+	     (match_operand:VNX2_QHSDI 4 "register_operand" " vr")] ORDER)
+	  (match_operand:VNX2_QHSD 2 "vector_merge_operand" "0vu")))]
+  "TARGET_VECTOR"
+  "vl<order>xei<VNX2_QHSDI:sew>.v\t%0,(%3),%4%p1"
+  [(set_attr "type" "vld<order>x")
+   (set_attr "mode" "<VNX2_QHSD:MODE>")])
+
+(define_insn "@pred_indexed_<order>store<VNX2_QHSD:mode><VNX2_QHSDI:mode>"
+  [(set (mem:BLK (scratch))
+	(unspec:BLK
+	  [(unspec:<VM>
+	    [(match_operand:<VM> 0 "vector_mask_operand" "vmWc1")
+	     (match_operand 4 "vector_length_operand"    "   rK")
+	     (match_operand 5 "const_int_operand"        "    i")
+	     (reg:SI VL_REGNUM)
+	     (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE)
+	   (match_operand 1 "pmode_register_operand"      "   r")
+	   (match_operand:VNX2_QHSDI 2 "register_operand" "  vr")
+	   (match_operand:VNX2_QHSD 3 "register_operand"  "  vr")] ORDER))]
+  "TARGET_VECTOR"
+  "vs<order>xei<VNX2_QHSDI:sew>.v\t%3,(%1),%2%p0"
+  [(set_attr "type" "vst<order>x")
+   (set_attr "mode" "<VNX2_QHSD:MODE>")])
+
+(define_insn "@pred_indexed_<order>load<VNX4_QHSD:mode><VNX4_QHSDI:mode>"
+  [(set (match_operand:VNX4_QHSD 0 "register_operand"      "=&vr")
+	(if_then_else:VNX4_QHSD
+	  (unspec:<VM>
+	    [(match_operand:<VM> 1 "vector_mask_operand"  "vmWc1")
+	     (match_operand 5 "vector_length_operand"     "   rK")
+	     (match_operand 6 "const_int_operand"         "    i")
+	     (match_operand 7 "const_int_operand"         "    i")
+	     (match_operand 8 "const_int_operand"         "    i")
+	     (reg:SI VL_REGNUM)
+	     (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE)
+	  (unspec:VNX4_QHSD
+	    [(match_operand 3 "pmode_register_operand"    "    r")
+	     (mem:BLK (scratch))
+	     (match_operand:VNX4_QHSDI 4 "register_operand" " vr")] ORDER)
+	  (match_operand:VNX4_QHSD 2 "vector_merge_operand" "0vu")))]
+  "TARGET_VECTOR"
+  "vl<order>xei<VNX4_QHSDI:sew>.v\t%0,(%3),%4%p1"
+  [(set_attr "type" "vld<order>x")
+   (set_attr "mode" "<VNX4_QHSD:MODE>")])
+
+(define_insn "@pred_indexed_<order>store<VNX4_QHSD:mode><VNX4_QHSDI:mode>"
+  [(set (mem:BLK (scratch))
+	(unspec:BLK
+	  [(unspec:<VM>
+	    [(match_operand:<VM> 0 "vector_mask_operand" "vmWc1")
+	     (match_operand 4 "vector_length_operand"    "   rK")
+	     (match_operand 5 "const_int_operand"        "    i")
+	     (reg:SI VL_REGNUM)
+	     (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE)
+	   (match_operand 1 "pmode_register_operand"      "   r")
+	   (match_operand:VNX4_QHSDI 2 "register_operand" "  vr")
+	   (match_operand:VNX4_QHSD 3 "register_operand"  "  vr")] ORDER))]
+  "TARGET_VECTOR"
+  "vs<order>xei<VNX4_QHSDI:sew>.v\t%3,(%1),%2%p0"
+  [(set_attr "type" "vst<order>x")
+   (set_attr "mode" "<VNX4_QHSD:MODE>")])
+
+(define_insn "@pred_indexed_<order>load<VNX8_QHSD:mode><VNX8_QHSDI:mode>"
+  [(set (match_operand:VNX8_QHSD 0 "register_operand"      "=&vr")
+	(if_then_else:VNX8_QHSD
+	  (unspec:<VM>
+	    [(match_operand:<VM> 1 "vector_mask_operand"  "vmWc1")
+	     (match_operand 5 "vector_length_operand"     "   rK")
+	     (match_operand 6 "const_int_operand"         "    i")
+	     (match_operand 7 "const_int_operand"         "    i")
+	     (match_operand 8 "const_int_operand"         "    i")
+	     (reg:SI VL_REGNUM)
+	     (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE)
+	  (unspec:VNX8_QHSD
+	    [(match_operand 3 "pmode_register_operand"    "    r")
+	     (mem:BLK (scratch))
+	     (match_operand:VNX8_QHSDI 4 "register_operand" " vr")] ORDER)
+	  (match_operand:VNX8_QHSD 2 "vector_merge_operand" "0vu")))]
+  "TARGET_VECTOR"
+  "vl<order>xei<VNX8_QHSDI:sew>.v\t%0,(%3),%4%p1"
+  [(set_attr "type" "vld<order>x")
+   (set_attr "mode" "<VNX8_QHSD:MODE>")])
+
+(define_insn "@pred_indexed_<order>store<VNX8_QHSD:mode><VNX8_QHSDI:mode>"
+  [(set (mem:BLK (scratch))
+	(unspec:BLK
+	  [(unspec:<VM>
+	    [(match_operand:<VM> 0 "vector_mask_operand" "vmWc1")
+	     (match_operand 4 "vector_length_operand"    "   rK")
+	     (match_operand 5 "const_int_operand"        "    i")
+	     (reg:SI VL_REGNUM)
+	     (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE)
+	   (match_operand 1 "pmode_register_operand"      "   r")
+	   (match_operand:VNX8_QHSDI 2 "register_operand" "  vr")
+	   (match_operand:VNX8_QHSD 3 "register_operand"  "  vr")] ORDER))]
+  "TARGET_VECTOR"
+  "vs<order>xei<VNX8_QHSDI:sew>.v\t%3,(%1),%2%p0"
+  [(set_attr "type" "vst<order>x")
+   (set_attr "mode" "<VNX8_QHSD:MODE>")])
+
+(define_insn "@pred_indexed_<order>load<VNX16_QHS:mode><VNX16_QHSI:mode>"
+  [(set (match_operand:VNX16_QHS 0 "register_operand"      "=&vr")
+	(if_then_else:VNX16_QHS
+	  (unspec:<VM>
+	    [(match_operand:<VM> 1 "vector_mask_operand"  "vmWc1")
+	     (match_operand 5 "vector_length_operand"     "   rK")
+	     (match_operand 6 "const_int_operand"         "    i")
+	     (match_operand 7 "const_int_operand"         "    i")
+	     (match_operand 8 "const_int_operand"         "    i")
+	     (reg:SI VL_REGNUM)
+	     (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE)
+	  (unspec:VNX16_QHS
+	    [(match_operand 3 "pmode_register_operand"    "    r")
+	     (mem:BLK (scratch))
+	     (match_operand:VNX16_QHSI 4 "register_operand" " vr")] ORDER)
+	  (match_operand:VNX16_QHS 2 "vector_merge_operand" "0vu")))]
+  "TARGET_VECTOR"
+  "vl<order>xei<VNX16_QHSI:sew>.v\t%0,(%3),%4%p1"
+  [(set_attr "type" "vld<order>x")
+   (set_attr "mode" "<VNX16_QHS:MODE>")])
+
+(define_insn "@pred_indexed_<order>store<VNX16_QHS:mode><VNX16_QHSI:mode>"
+  [(set (mem:BLK (scratch))
+	(unspec:BLK
+	  [(unspec:<VM>
+	    [(match_operand:<VM> 0 "vector_mask_operand" "vmWc1")
+	     (match_operand 4 "vector_length_operand"    "   rK")
+	     (match_operand 5 "const_int_operand"        "    i")
+	     (reg:SI VL_REGNUM)
+	     (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE)
+	   (match_operand 1 "pmode_register_operand"      "   r")
+	   (match_operand:VNX16_QHSI 2 "register_operand" "  vr")
+	   (match_operand:VNX16_QHS 3 "register_operand"  "  vr")] ORDER))]
+  "TARGET_VECTOR"
+  "vs<order>xei<VNX16_QHSI:sew>.v\t%3,(%1),%2%p0"
+  [(set_attr "type" "vst<order>x")
+   (set_attr "mode" "<VNX16_QHS:MODE>")])
+
+(define_insn "@pred_indexed_<order>load<VNX32_QH:mode><VNX32_QHI:mode>"
+  [(set (match_operand:VNX32_QH 0 "register_operand"      "=&vr")
+	(if_then_else:VNX32_QH
+	  (unspec:<VM>
+	    [(match_operand:<VM> 1 "vector_mask_operand"  "vmWc1")
+	     (match_operand 5 "vector_length_operand"     "   rK")
+	     (match_operand 6 "const_int_operand"         "    i")
+	     (match_operand 7 "const_int_operand"         "    i")
+	     (match_operand 8 "const_int_operand"         "    i")
+	     (reg:SI VL_REGNUM)
+	     (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE)
+	  (unspec:VNX32_QH
+	    [(match_operand 3 "pmode_register_operand"    "    r")
+	     (mem:BLK (scratch))
+	     (match_operand:VNX32_QHI 4 "register_operand"  " vr")] ORDER)
+	  (match_operand:VNX32_QH 2 "vector_merge_operand"  "0vu")))]
+  "TARGET_VECTOR"
+  "vl<order>xei<VNX32_QHI:sew>.v\t%0,(%3),%4%p1"
+  [(set_attr "type" "vld<order>x")
+   (set_attr "mode" "<VNX32_QH:MODE>")])
+
+(define_insn "@pred_indexed_<order>store<VNX32_QH:mode><VNX32_QHI:mode>"
+  [(set (mem:BLK (scratch))
+	(unspec:BLK
+	  [(unspec:<VM>
+	    [(match_operand:<VM> 0 "vector_mask_operand" "vmWc1")
+	     (match_operand 4 "vector_length_operand"    "   rK")
+	     (match_operand 5 "const_int_operand"        "    i")
+	     (reg:SI VL_REGNUM)
+	     (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE)
+	   (match_operand 1 "pmode_register_operand"      "   r")
+	   (match_operand:VNX32_QHI 2 "register_operand"  "  vr")
+	   (match_operand:VNX32_QH 3 "register_operand"   "  vr")] ORDER))]
+  "TARGET_VECTOR"
+  "vs<order>xei<VNX32_QHI:sew>.v\t%3,(%1),%2%p0"
+  [(set_attr "type" "vst<order>x")
+   (set_attr "mode" "<VNX32_QH:MODE>")])
+
+(define_insn "@pred_indexed_<order>load<VNX64_Q:mode><VNX64_Q:mode>"
+  [(set (match_operand:VNX64_Q 0 "register_operand"      "=&vr")
+	(if_then_else:VNX64_Q
+	  (unspec:<VM>
+	    [(match_operand:<VM> 1 "vector_mask_operand"  "vmWc1")
+	     (match_operand 5 "vector_length_operand"     "   rK")
+	     (match_operand 6 "const_int_operand"         "    i")
+	     (match_operand 7 "const_int_operand"         "    i")
+	     (match_operand 8 "const_int_operand"         "    i")
+	     (reg:SI VL_REGNUM)
+	     (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE)
+	  (unspec:VNX64_Q
+	    [(match_operand 3 "pmode_register_operand"    "    r")
+	     (mem:BLK (scratch))
+	     (match_operand:VNX64_Q 4 "register_operand"    " vr")] ORDER)
+	  (match_operand:VNX64_Q 2 "vector_merge_operand"   "0vu")))]
+  "TARGET_VECTOR"
+  "vl<order>xei<VNX64_Q:sew>.v\t%0,(%3),%4%p1"
+  [(set_attr "type" "vld<order>x")
+   (set_attr "mode" "<VNX64_Q:MODE>")])
+
+(define_insn "@pred_indexed_<order>store<VNX64_Q:mode><VNX64_Q:mode>"
+  [(set (mem:BLK (scratch))
+	(unspec:BLK
+	  [(unspec:<VM>
+	    [(match_operand:<VM> 0 "vector_mask_operand" "vmWc1")
+	     (match_operand 4 "vector_length_operand"    "   rK")
+	     (match_operand 5 "const_int_operand"        "    i")
+	     (reg:SI VL_REGNUM)
+	     (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE)
+	   (match_operand 1 "pmode_register_operand"      "   r")
+	   (match_operand:VNX64_Q 2 "register_operand"    "  vr")
+	   (match_operand:VNX64_Q 3 "register_operand"    "  vr")] ORDER))]
+  "TARGET_VECTOR"
+  "vs<order>xei<VNX64_Q:sew>.v\t%3,(%1),%2%p0"
+  [(set_attr "type" "vst<order>x")
+   (set_attr "mode" "<VNX64_Q:MODE>")])
diff --git a/gcc/config/rs6000/rs6000-overload.def b/gcc/config/rs6000/rs6000-overload.def
index 20cc031..c582490 100644
--- a/gcc/config/rs6000/rs6000-overload.def
+++ b/gcc/config/rs6000/rs6000-overload.def
@@ -5930,7 +5930,7 @@
   unsigned int __builtin_vec_scalar_test_data_class_sp (float, const int);
     VSTDCSP  VSTDCSP_DEPR1
 
-[VEC_VSUBCUQ, vec_vsubcuqP, __builtin_vec_vsubcuq]
+[VEC_VSUBCUQ, vec_vsubcuq, __builtin_vec_vsubcuq]
   vsq __builtin_vec_vsubcuq (vsq, vsq);
     VSUBCUQ  VSUBCUQ_DEPR1
   vuq __builtin_vec_vsubcuq (vuq, vuq);
diff --git a/gcc/config/rs6000/rs6000.cc b/gcc/config/rs6000/rs6000.cc
index 1b8ed7a..16ca3a3 100644
--- a/gcc/config/rs6000/rs6000.cc
+++ b/gcc/config/rs6000/rs6000.cc
@@ -28928,9 +28928,9 @@ constant_generates_xxspltidp (vec_const_128bit_type *vsx_const)
    __vector_pair built-in types.  They are target specific and
    only available when MMA is supported.  With MMA supported, it
    simply returns true, otherwise it checks if the given gimple
-   STMT is an assignment or asm stmt and uses either of these two
-   opaque types unexpectedly, if yes, it would raise an error
-   message and returns true, otherwise it returns false.  */
+   STMT is an assignment, asm or call stmt and uses either of
+   these two opaque types unexpectedly, if yes, it would raise
+   an error message and returns true, otherwise it returns false.  */
 
 bool
 rs6000_opaque_type_invalid_use_p (gimple *stmt)
@@ -28959,7 +28959,7 @@ rs6000_opaque_type_invalid_use_p (gimple *stmt)
   if (stmt)
     {
       /* The usage of MMA opaque types is very limited for now,
-	 to check with gassign and gasm is enough so far.  */
+	 to check with gassign, gasm and gcall is enough so far.  */
       if (gassign *ga = dyn_cast<gassign *> (stmt))
 	{
 	  tree lhs = gimple_assign_lhs (ga);
@@ -28988,6 +28988,17 @@ rs6000_opaque_type_invalid_use_p (gimple *stmt)
 		return true;
 	    }
 	}
+      else if (gcall *gc = dyn_cast<gcall *> (stmt))
+	{
+	  unsigned nargs = gimple_call_num_args (gc);
+	  for (unsigned i = 0; i < nargs; i++)
+	    {
+	      tree arg = gimple_call_arg (gc, i);
+	      tree type = TREE_TYPE (arg);
+	      if (check_and_error_invalid_use (type))
+		return true;
+	    }
+	}
     }
 
   return false;
diff --git a/gcc/config/s390/s390-d.cc b/gcc/config/s390/s390-d.cc
index d10b45f..6e9c80f 100644
--- a/gcc/config/s390/s390-d.cc
+++ b/gcc/config/s390/s390-d.cc
@@ -30,10 +30,11 @@ along with GCC; see the file COPYING3.  If not see
 void
 s390_d_target_versions (void)
 {
-  if (TARGET_ZARCH)
-    d_add_builtin_version ("SystemZ");
-  else if (TARGET_64BIT)
-    d_add_builtin_version ("S390X");
+  if (TARGET_64BIT)
+    {
+      d_add_builtin_version ("S390X");
+      d_add_builtin_version ("SystemZ");
+    }
   else
     d_add_builtin_version ("S390");
 
diff --git a/gcc/config/sol2.h b/gcc/config/sol2.h
index 05dbaff..616f9b9 100644
--- a/gcc/config/sol2.h
+++ b/gcc/config/sol2.h
@@ -295,7 +295,7 @@ along with GCC; see the file COPYING3.  If not see
 
 #undef  ENDFILE_SPEC
 #define ENDFILE_SPEC \
-  "%{Ofast|ffast-math|funsafe-math-optimizations:crtfastmath.o%s} \
+  "%{Ofast|ffast-math|funsafe-math-optimizations:%{!shared:crtfastmath.o%s}} \
    %(endfile_arch) %(endfile_vtv) %(endfile_crtend) crtn.o%s"
 
 #undef LINK_ARCH32_SPEC_BASE
diff --git a/gcc/config/sparc/freebsd.h b/gcc/config/sparc/freebsd.h
index b1ae4ba..f77203c 100644
--- a/gcc/config/sparc/freebsd.h
+++ b/gcc/config/sparc/freebsd.h
@@ -127,7 +127,7 @@ along with GCC; see the file COPYING3.  If not see
 
 #undef ENDFILE_SPEC
 #define ENDFILE_SPEC						\
-  "%{Ofast|ffast-math|funsafe-math-optimizations:crtfastmath.o%s} "	\
+  "%{Ofast|ffast-math|funsafe-math-optimizations:%{!shared:crtfastmath.o%s}} "	\
   FBSD_ENDFILE_SPEC
 
 /* We use GNU ld so undefine this so that attribute((init_priority)) works.  */
diff --git a/gcc/config/sparc/linux.h b/gcc/config/sparc/linux.h
index a1144da..0e33b3c 100644
--- a/gcc/config/sparc/linux.h
+++ b/gcc/config/sparc/linux.h
@@ -30,7 +30,7 @@ along with GCC; see the file COPYING3.  If not see
 #undef  ENDFILE_SPEC
 #define ENDFILE_SPEC \
   GNU_USER_TARGET_ENDFILE_SPEC \
-  "%{Ofast|ffast-math|funsafe-math-optimizations:crtfastmath.o%s}"
+  "%{Ofast|ffast-math|funsafe-math-optimizations:%{!shared:crtfastmath.o%s}}"
 
 /* -mcpu=native handling only makes sense with compiler running on
    a SPARC chip.  */
diff --git a/gcc/config/sparc/linux64.h b/gcc/config/sparc/linux64.h
index 80aa703..f1cc0a1 100644
--- a/gcc/config/sparc/linux64.h
+++ b/gcc/config/sparc/linux64.h
@@ -47,7 +47,7 @@ along with GCC; see the file COPYING3.  If not see
 #undef	ENDFILE_SPEC
 #define ENDFILE_SPEC \
   GNU_USER_TARGET_ENDFILE_SPEC \
-  "%{Ofast|ffast-math|funsafe-math-optimizations:crtfastmath.o%s}"
+  "%{Ofast|ffast-math|funsafe-math-optimizations:%{!shared:crtfastmath.o%s}}"
 
 /* The default code model.  */
 #undef SPARC_DEFAULT_CMODEL
diff --git a/gcc/config/sparc/sp-elf.h b/gcc/config/sparc/sp-elf.h
index fdd5c57..0d6a9af 100644
--- a/gcc/config/sparc/sp-elf.h
+++ b/gcc/config/sparc/sp-elf.h
@@ -32,7 +32,7 @@ along with GCC; see the file COPYING3.  If not see
 
 #undef ENDFILE_SPEC
 #define ENDFILE_SPEC \
-  "%{Ofast|ffast-math|funsafe-math-optimizations:crtfastmath.o%s} \
+  "%{Ofast|ffast-math|funsafe-math-optimizations:%{!shared:crtfastmath.o%s}} \
    crtend.o%s crtn.o%s"
 
 /* Don't set the target flags, this is done by the linker script */
diff --git a/gcc/config/sparc/sp64-elf.h b/gcc/config/sparc/sp64-elf.h
index 1f476cd..11c9504 100644
--- a/gcc/config/sparc/sp64-elf.h
+++ b/gcc/config/sparc/sp64-elf.h
@@ -44,7 +44,7 @@ along with GCC; see the file COPYING3.  If not see
 
 #undef ENDFILE_SPEC
 #define ENDFILE_SPEC \
-  "%{Ofast|ffast-math|funsafe-math-optimizations:crtfastmath.o%s} \
+  "%{Ofast|ffast-math|funsafe-math-optimizations:%{!shared:crtfastmath.o%s}} \
    crtend.o%s crtn.o%s"
 
 /* Use the default (for now).  */
diff --git a/gcc/config/v850/v850.cc b/gcc/config/v850/v850.cc
index 7143a2e..367ba03 100644
--- a/gcc/config/v850/v850.cc
+++ b/gcc/config/v850/v850.cc
@@ -2865,7 +2865,6 @@ v850_select_section (tree exp,
     {
       int is_const;
       if (!TREE_READONLY (exp)
-	  || TREE_SIDE_EFFECTS (exp)
 	  || !DECL_INITIAL (exp)
 	  || (DECL_INITIAL (exp) != error_mark_node
 	      && !TREE_CONSTANT (DECL_INITIAL (exp))))
diff --git a/gcc/config/xtensa/xtensa.md b/gcc/config/xtensa/xtensa.md
index 98f3c46..d3996b2 100644
--- a/gcc/config/xtensa/xtensa.md
+++ b/gcc/config/xtensa/xtensa.md
@@ -736,7 +736,31 @@
    (set_attr "mode"	"SI")
    (set_attr "length"	"3")])
 
-(define_insn "xorsi3"
+(define_expand "xorsi3"
+  [(set (match_operand:SI 0 "register_operand")
+	(xor:SI (match_operand:SI 1 "register_operand")
+		(match_operand:SI 2 "nonmemory_operand")))]
+  ""
+{
+  if (register_operand (operands[2], SImode))
+    emit_insn (gen_xorsi3_internal (operands[0], operands[1],
+				    operands[2]));
+  else
+    {
+      rtx (*gen_op)(rtx, rtx, rtx);
+      if (TARGET_DENSITY
+	  && CONST_INT_P (operands[2])
+	  && INTVAL (operands[2]) == -2147483648L)
+	gen_op = gen_addsi3;
+      else
+	gen_op = gen_xorsi3_internal;
+      emit_insn (gen_op (operands[0], operands[1],
+			 force_reg (SImode, operands[2])));
+    }
+  DONE;
+})
+
+(define_insn "xorsi3_internal"
   [(set (match_operand:SI 0 "register_operand" "=a")
 	(xor:SI (match_operand:SI 1 "register_operand" "%r")
 		(match_operand:SI 2 "register_operand" "r")))]
@@ -2949,45 +2973,47 @@
 {
   auto_sbitmap bmp (FIRST_PSEUDO_REGISTER);
   rtx_insn *insn;
-  rtx reg = gen_rtx_REG (SImode, 0);
+  rtx reg = gen_rtx_REG (SImode, 0), dest;
+  unsigned int regno;
+  sbitmap_iterator iter;
   bitmap_set_range (bmp, REGNO (operands[0]), REG_NREGS (operands[0]));
   for (insn = next_nonnote_nondebug_insn_bb (curr_insn);
        insn; insn = next_nonnote_nondebug_insn_bb (insn))
-    {
-      sbitmap_iterator iter;
-      unsigned int regno;
-      if (NONJUMP_INSN_P (insn))
-	{
-	  EXECUTE_IF_SET_IN_BITMAP (bmp, 2, regno, iter)
-	    {
-	      set_regno_raw (reg, regno, REG_NREGS (reg));
-	      if (reg_overlap_mentioned_p (reg, PATTERN (insn)))
-		break;
-	    }
-	  if (GET_CODE (PATTERN (insn)) == SET)
-	    {
-	      rtx x = SET_DEST (PATTERN (insn));
-	      if (REG_P (x) && HARD_REGISTER_P (x))
-		bitmap_clear_range (bmp, REGNO (x), REG_NREGS (x));
-	      else if (SUBREG_P (x) && HARD_REGISTER_P (SUBREG_REG (x)))
-		{
-		  struct subreg_info info;
-		  subreg_get_info (regno = REGNO (SUBREG_REG (x)),
-				   GET_MODE (SUBREG_REG (x)),
-				   SUBREG_BYTE (x), GET_MODE (x), &info);
-		  if (!info.representable_p)
-		    break;
-		  bitmap_clear_range (bmp, regno + info.offset, info.nregs);
-		}
-	    }
-	  if (bitmap_empty_p (bmp))
-	    goto FALLTHRU;
-	}
-      else if (CALL_P (insn))
+    if (NONJUMP_INSN_P (insn))
+      {
 	EXECUTE_IF_SET_IN_BITMAP (bmp, 2, regno, iter)
-	 if (call_used_or_fixed_reg_p (regno))
-	   break;
-    }
+	  {
+	    set_regno_raw (reg, regno, REG_NREGS (reg));
+	    if (reg_referenced_p (reg, PATTERN (insn)))
+	      goto ABORT;
+	  }
+	if (GET_CODE (PATTERN (insn)) == SET
+	    || GET_CODE (PATTERN (insn)) == CLOBBER)
+	  {
+	    dest = SET_DEST (PATTERN (insn));
+	    if (REG_P (dest) && HARD_REGISTER_P (dest))
+	      bitmap_clear_range (bmp, REGNO (dest), REG_NREGS (dest));
+	    else if (SUBREG_P (dest)
+		     && HARD_REGISTER_P (SUBREG_REG (dest)))
+	      {
+		struct subreg_info info;
+		subreg_get_info (regno = REGNO (SUBREG_REG (dest)),
+				 GET_MODE (SUBREG_REG (dest)),
+				 SUBREG_BYTE (dest), GET_MODE (dest),
+				 &info);
+		if (!info.representable_p)
+		  break;
+		bitmap_clear_range (bmp, regno + info.offset, info.nregs);
+	      }
+	  }
+	if (bitmap_empty_p (bmp))
+	  goto FALLTHRU;
+      }
+    else if (CALL_P (insn))
+      EXECUTE_IF_SET_IN_BITMAP (bmp, 2, regno, iter)
+	if (call_used_or_fixed_reg_p (regno))
+	  goto ABORT;
+ABORT:
   FAIL;
 FALLTHRU:;
 })
diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 5c91d4b..bb6ddc0 100644
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,120 @@
+2023-01-26  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/105300
+	* parser.cc: Remove unnecessary forward declarations.
+	(cp_parser_string_literal): New wrapper.
+	(cp_parser_string_literal_common): Renamed from
+	cp_parser_string_literal.  Add a bool parameter.  Give an error when
+	UDLs are not permitted.
+	(cp_parser_userdef_string_literal): New wrapper.
+	(finish_userdef_string_literal): Renamed from
+	cp_parser_userdef_string_literal.
+	(cp_parser_primary_expression): Call cp_parser_userdef_string_literal
+	instead of cp_parser_string_literal.
+	(cp_parser_linkage_specification): Move a variable declaration closer
+	to its first use.
+	(cp_parser_static_assert): Likewise.
+	(cp_parser_operator): Call cp_parser_userdef_string_literal instead of
+	cp_parser_string_literal.
+	(cp_parser_asm_definition): Move a variable declaration closer to its
+	first use.
+	(cp_parser_asm_specification_opt): Move variable declarations closer to
+	their first use.
+	(cp_parser_asm_operand_list): Likewise.
+	(cp_parser_asm_clobber_list): Likewise.
+
+2023-01-26  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/108503
+	* parser.cc (cp_convert_omp_range_for): If cp_finish_decomp has been
+	called in !processing_template_decl with processing_template_decl
+	temporarily set, clear DECL_HAS_VALUE_EXPR_P on the vars temporarily.
+	(cp_finish_omp_range_for): And set it back again here.
+
+2023-01-25  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/108525
+	* mangle.cc (write_closure_type_name): Don't assume all
+	lambda operator() fns are methods.
+
+2023-01-24  Jason Merrill  <jason@redhat.com>
+
+	PR c++/108504
+	* parser.cc (cp_lexer_new_main): Pass C_LEX_STRING_NO_JOIN for first
+	token, too.
+
+2023-01-24  Jason Merrill  <jason@redhat.com>
+
+	PR c++/108526
+	* pt.cc (tsubst_function_decl): Handle static lambda.
+
+2023-01-24  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/108474
+	* cp-gimplify.cc (cp_fold_r): Revert 2023-01-19 changes.
+
+2023-01-24  Jason Merrill  <jason@redhat.com>
+
+	PR c++/107303
+	PR c++/107329
+	* cp-gimplify.cc (cp_fold_r) [TARGET_EXPR]: In case of double
+	TARGET_EXPR, keep the outer one instead of the inner one.
+	(maybe_replace_decl): New.
+
+2023-01-23  Jason Merrill  <jason@redhat.com>
+
+	PR c++/107267
+	* cp-gimplify.cc (cp_gimplify_init_expr): Allow unexpected elision
+	of trivial types.
+
+2023-01-23  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/107797
+	* cvt.cc (ocp_convert): copy_warning when creating a new
+	COMPOUND_EXPR.
+	* init.cc (build_new_1): Suppress -Wunused-value on
+	compiler-generated COMPOUND_EXPRs.
+
+2023-01-23  Jason Merrill  <jason@redhat.com>
+
+	PR c++/108195
+	* call.cc (build_user_type_conversion_1): Check whether the
+	iterators also find a list ctor.
+
+2023-01-23  Jason Merrill  <jason@redhat.com>
+
+	PR c++/108496
+	* decl.cc (grokdeclarator): Check whether DECL_RESULT is already
+	set.
+
+2023-01-23  Jason Merrill  <jason@redhat.com>
+
+	PR c++/53288
+	DR 1299
+	* call.cc (extend_ref_init_temps_1): Handle ptrmem expression.
+
+2023-01-19  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/108437
+	* cp-tree.h (keep_unused_object_arg): Declare.
+	* call.cc (keep_unused_object_arg): No longer static.
+	* tree.cc (build_min_non_dep_op_overload): Handle ARRAY_REF
+	with overload being static member function.
+
+2023-01-19  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/53932
+	* cp-gimplify.cc (cp_fold_r): During cp_fully_fold_init replace
+	DECL_ANON_UNION_VAR_P VAR_DECLs with their corresponding
+	DECL_VALUE_EXPR.
+
+2023-01-16  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/105593
+	* decl.cc (cp_finish_decl): Check warning_enabled_at
+	at the DECL_SOURCE_LOCATION (decl) for OPT_Winit_self instead
+	of warn_init_self.
+
 2023-01-14  Jakub Jelinek  <jakub@redhat.com>
 
 	PR c++/108365
diff --git a/gcc/cp/call.cc b/gcc/cp/call.cc
index 0780b58..5715a7c 100644
--- a/gcc/cp/call.cc
+++ b/gcc/cp/call.cc
@@ -4581,7 +4581,7 @@ build_user_type_conversion_1 (tree totype, tree expr, int flags,
   if (tree iters = maybe_init_list_as_range (cand->fn, expr))
     if (z_candidate *cand2
 	= build_user_type_conversion_1 (totype, iters, flags, tf_none))
-      if (cand2->viable == 1)
+      if (cand2->viable == 1 && !is_list_ctor (cand2->fn))
 	{
 	  cand = cand2;
 	  expr = iters;
@@ -5187,7 +5187,7 @@ build_operator_new_call (tree fnname, vec<tree, va_gc> **args,
    or static operator(), in which cases the source expression
    would be `obj[...]' or `obj(...)'.  */
 
-static tree
+tree
 keep_unused_object_arg (tree result, tree obj, tree fn)
 {
   if (result == NULL_TREE
@@ -13952,6 +13952,34 @@ static tree
 extend_ref_init_temps_1 (tree decl, tree init, vec<tree, va_gc> **cleanups,
 			 tree *cond_guard)
 {
+  /* CWG1299 (C++20): The temporary object to which the reference is bound or
+     the temporary object that is the complete object of a subobject to which
+     the reference is bound persists for the lifetime of the reference if the
+     glvalue to which the reference is bound was obtained through one of the
+     following:
+     - a temporary materialization conversion ([conv.rval]),
+     - ( expression ), where expression is one of these expressions,
+     - subscripting ([expr.sub]) of an array operand, where that operand is one
+       of these expressions,
+     - a class member access ([expr.ref]) using the . operator where the left
+       operand is one of these expressions and the right operand designates a
+       non-static data member of non-reference type,
+     - a pointer-to-member operation ([expr.mptr.oper]) using the .* operator
+       where the left operand is one of these expressions and the right operand
+       is a pointer to data member of non-reference type,
+     - a const_cast ([expr.const.cast]), static_cast ([expr.static.cast]),
+       dynamic_cast ([expr.dynamic.cast]), or reinterpret_cast
+       ([expr.reinterpret.cast]) converting, without a user-defined conversion,
+       a glvalue operand that is one of these expressions to a glvalue that
+       refers to the object designated by the operand, or to its complete
+       object or a subobject thereof,
+     - a conditional expression ([expr.cond]) that is a glvalue where the
+       second or third operand is one of these expressions, or
+     - a comma expression ([expr.comma]) that is a glvalue where the right
+       operand is one of these expressions.  */
+
+  /* FIXME several cases are still handled wrong (101572, 81420).  */
+
   tree sub = init;
   tree *p;
   STRIP_NOPS (sub);
@@ -13962,6 +13990,16 @@ extend_ref_init_temps_1 (tree decl, tree init, vec<tree, va_gc> **cleanups,
 				   cond_guard);
       return init;
     }
+  if (TREE_CODE (sub) == POINTER_PLUS_EXPR
+      && TYPE_PTRDATAMEM_P (TREE_TYPE (tree_strip_nop_conversions
+				       (TREE_OPERAND (sub, 1)))))
+    {
+      /* A pointer-to-member operation.  */
+      TREE_OPERAND (sub, 0)
+	= extend_ref_init_temps_1 (decl, TREE_OPERAND (sub, 0), cleanups,
+				   cond_guard);
+      return init;
+    }
   if (TREE_CODE (sub) == COND_EXPR)
     {
       tree cur_cond_guard = NULL_TREE;
diff --git a/gcc/cp/cp-gimplify.cc b/gcc/cp/cp-gimplify.cc
index a282156..a35cedd 100644
--- a/gcc/cp/cp-gimplify.cc
+++ b/gcc/cp/cp-gimplify.cc
@@ -250,7 +250,10 @@ cp_gimplify_init_expr (tree *expr_p)
   if (TREE_CODE (from) == TARGET_EXPR)
     if (tree init = TARGET_EXPR_INITIAL (from))
       {
-	gcc_checking_assert (TARGET_EXPR_ELIDING_P (from));
+	/* Make sure that we expected to elide this temporary.  But also allow
+	   gimplify_modify_expr_rhs to elide temporaries of trivial type.  */
+	gcc_checking_assert (TARGET_EXPR_ELIDING_P (from)
+			     || !TREE_ADDRESSABLE (TREE_TYPE (from)));
 	if (target_expr_needs_replace (from))
 	  {
 	    /* If this was changed by cp_genericize_target_expr, we need to
@@ -949,6 +952,28 @@ cp_genericize_target_expr (tree *stmt_p)
   gcc_assert (!DECL_INITIAL (slot));
 }
 
+/* Similar to if (target_expr_needs_replace) replace_decl, but TP is the
+   TARGET_EXPR_INITIAL, and this also updates *_SLOT.  We need this extra
+   replacement when cp_folding TARGET_EXPR to preserve the invariant that
+   AGGR_INIT_EXPR_SLOT agrees with the enclosing TARGET_EXPR_SLOT.  */
+
+bool
+maybe_replace_decl (tree *tp, tree decl, tree replacement)
+{
+  if (!*tp || !VOID_TYPE_P (TREE_TYPE (*tp)))
+    return false;
+  tree t = *tp;
+  while (TREE_CODE (t) == COMPOUND_EXPR)
+    t = TREE_OPERAND (t, 1);
+  if (TREE_CODE (t) == AGGR_INIT_EXPR)
+    replace_decl (&AGGR_INIT_EXPR_SLOT (t), decl, replacement);
+  else if (TREE_CODE (t) == VEC_INIT_EXPR)
+    replace_decl (&VEC_INIT_EXPR_SLOT (t), decl, replacement);
+  else
+    replace_decl (tp, decl, replacement);
+  return true;
+}
+
 /* Genericization context.  */
 
 struct cp_genericize_data
@@ -1103,15 +1128,18 @@ cp_fold_r (tree *stmt_p, int *walk_subtrees, void *data_)
 	cp_genericize_target_expr (stmt_p);
 
       /* Folding might replace e.g. a COND_EXPR with a TARGET_EXPR; in
-	 that case, use it in place of this one.  */
+	 that case, strip it in favor of this one.  */
       if (tree &init = TARGET_EXPR_INITIAL (stmt))
 	{
 	  cp_walk_tree (&init, cp_fold_r, data, NULL);
+	  cp_walk_tree (&TARGET_EXPR_CLEANUP (stmt), cp_fold_r, data, NULL);
 	  *walk_subtrees = 0;
 	  if (TREE_CODE (init) == TARGET_EXPR)
 	    {
-	      TARGET_EXPR_ELIDING_P (init) = TARGET_EXPR_ELIDING_P (stmt);
-	      *stmt_p = init;
+	      tree sub = TARGET_EXPR_INITIAL (init);
+	      maybe_replace_decl (&sub, TARGET_EXPR_SLOT (init),
+				  TARGET_EXPR_SLOT (stmt));
+	      init = sub;
 	    }
 	}
       break;
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index d3058c0..9f18872 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -6599,6 +6599,7 @@ inline tree build_new_op (const op_location_t &loc, enum tree_code code,
   return build_new_op (loc, code, flags, arg1, arg2, NULL_TREE, NULL_TREE,
 		       NULL, complain);
 }
+extern tree keep_unused_object_arg		(tree, tree, tree);
 extern tree build_op_call			(tree, vec<tree, va_gc> **,
 						 tsubst_flags_t);
 extern tree build_op_subscript			(const op_location_t &, tree,
diff --git a/gcc/cp/cvt.cc b/gcc/cp/cvt.cc
index 0cbfd80..17827d0 100644
--- a/gcc/cp/cvt.cc
+++ b/gcc/cp/cvt.cc
@@ -711,8 +711,10 @@ ocp_convert (tree type, tree expr, int convtype, int flags,
 	return error_mark_node;
       if (e == TREE_OPERAND (expr, 1))
 	return expr;
-      return build2_loc (EXPR_LOCATION (expr), COMPOUND_EXPR, TREE_TYPE (e),
-			 TREE_OPERAND (expr, 0), e);
+      e = build2_loc (EXPR_LOCATION (expr), COMPOUND_EXPR, TREE_TYPE (e),
+		      TREE_OPERAND (expr, 0), e);
+      copy_warning (e, expr);
+      return e;
     }
 
   complete_type (type);
diff --git a/gcc/cp/decl.cc b/gcc/cp/decl.cc
index 75ddf80..d606b31 100644
--- a/gcc/cp/decl.cc
+++ b/gcc/cp/decl.cc
@@ -14776,7 +14776,9 @@ grokdeclarator (const cp_declarator *declarator,
       {
 	/* If we saw a return type, record its location.  */
 	location_t loc = declspecs->locations[ds_type_spec];
-	if (loc != UNKNOWN_LOCATION)
+	if (loc == UNKNOWN_LOCATION)
+	  /* Build DECL_RESULT in start_preparsed_function.  */;
+	else if (!DECL_RESULT (decl))
 	  {
 	    tree restype = TREE_TYPE (TREE_TYPE (decl));
 	    tree resdecl = build_decl (loc, RESULT_DECL, 0, restype);
@@ -14784,6 +14786,8 @@ grokdeclarator (const cp_declarator *declarator,
 	    DECL_IGNORED_P (resdecl) = 1;
 	    DECL_RESULT (decl) = resdecl;
 	  }
+	else if (funcdef_flag)
+	  DECL_SOURCE_LOCATION (DECL_RESULT (decl)) = loc;
       }
 
     /* Record constancy and volatility on the DECL itself .  There's
diff --git a/gcc/cp/init.cc b/gcc/cp/init.cc
index f816c47..52e96fb 100644
--- a/gcc/cp/init.cc
+++ b/gcc/cp/init.cc
@@ -3800,6 +3800,8 @@ build_new_1 (vec<tree, va_gc> **placement, tree type, tree nelts,
   if (cookie_expr)
     rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), cookie_expr, rval);
 
+  suppress_warning (rval, OPT_Wunused_value);
+
   if (rval == data_addr && TREE_CODE (alloc_expr) == TARGET_EXPR)
     /* If we don't have an initializer or a cookie, strip the TARGET_EXPR
        and return the call (which doesn't need to be adjusted).  */
diff --git a/gcc/cp/mangle.cc b/gcc/cp/mangle.cc
index 62e9f9f..f2cda3b 100644
--- a/gcc/cp/mangle.cc
+++ b/gcc/cp/mangle.cc
@@ -1816,7 +1816,7 @@ write_closure_type_name (const tree type)
       if (abi_warn_or_compat_version_crosses (18))
 	G.need_abi_warning = true;
 
-  write_method_parms (parms, /*method_p=*/1, fn);
+  write_method_parms (parms, TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE, fn);
   write_char ('E');
   if ((LAMBDA_EXPR_SCOPE_SIG_DISCRIMINATOR (lambda)
        != LAMBDA_EXPR_SCOPE_ONLY_DISCRIMINATOR (lambda))
diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc
index b38c22e..4cdc1cd 100644
--- a/gcc/cp/parser.cc
+++ b/gcc/cp/parser.cc
@@ -705,7 +705,7 @@ cp_lexer_new_main (void)
   /* It's possible that parsing the first pragma will load a PCH file,
      which is a GC collection point.  So we have to do that before
      allocating any memory.  */
-  cp_lexer_get_preprocessor_token (0, &token);
+  cp_lexer_get_preprocessor_token (C_LEX_STRING_NO_JOIN, &token);
   cp_parser_initial_pragma (&token);
   c_common_no_more_pch ();
 
@@ -2227,16 +2227,8 @@ pop_unparsed_function_queues (cp_parser *parser)
 
 /* Lexical conventions [gram.lex]  */
 
-static cp_expr cp_parser_identifier
-  (cp_parser *);
-static cp_expr cp_parser_string_literal
-  (cp_parser *, bool, bool, bool);
-static cp_expr cp_parser_userdef_char_literal
-  (cp_parser *);
-static tree cp_parser_userdef_string_literal
+static tree finish_userdef_string_literal
   (tree);
-static cp_expr cp_parser_userdef_numeric_literal
-  (cp_parser *);
 
 /* Basic concepts [gram.basic]  */
 
@@ -4408,11 +4400,15 @@ cp_parser_identifier (cp_parser* parser)
     return error_mark_node;
 }
 
-/* Parse a sequence of adjacent string constants.  Returns a
+/* Worker for cp_parser_string_literal and cp_parser_userdef_string_literal.
+   Do not call this directly; use either of the above.
+
+   Parse a sequence of adjacent string constants.  Return a
    TREE_STRING representing the combined, nul-terminated string
    constant.  If TRANSLATE is true, translate the string to the
    execution character set.  If WIDE_OK is true, a wide string is
-   invalid here.
+   valid here.  If UDL_OK is true, a string literal with user-defined
+   suffix can be used in this context.
 
    C++98 [lex.string] says that if a narrow string literal token is
    adjacent to a wide string literal token, the behavior is undefined.
@@ -4422,9 +4418,11 @@ cp_parser_identifier (cp_parser* parser)
    This code is largely lifted from lex_string() in c-lex.cc.
 
    FUTURE: ObjC++ will need to handle @-strings here.  */
+
 static cp_expr
-cp_parser_string_literal (cp_parser *parser, bool translate, bool wide_ok,
-			  bool lookup_udlit = true)
+cp_parser_string_literal_common (cp_parser *parser, bool translate,
+				 bool wide_ok, bool udl_ok,
+				 bool lookup_udlit)
 {
   tree value;
   size_t count;
@@ -4449,6 +4447,12 @@ cp_parser_string_literal (cp_parser *parser, bool translate, bool wide_ok,
 
   if (cpp_userdef_string_p (tok->type))
     {
+      if (!udl_ok)
+	{
+	  error_at (loc, "string literal with user-defined suffix "
+		    "is invalid in this context");
+	  return error_mark_node;
+	}
       string_tree = USERDEF_LITERAL_VALUE (tok->u.value);
       curr_type = cpp_userdef_string_remove_type (tok->type);
       curr_tok_is_userdef_p = true;
@@ -4539,6 +4543,12 @@ cp_parser_string_literal (cp_parser *parser, bool translate, bool wide_ok,
 	  tok = cp_lexer_peek_token (parser->lexer);
 	  if (cpp_userdef_string_p (tok->type))
 	    {
+	      if (!udl_ok)
+		{
+		  error_at (loc, "string literal with user-defined suffix "
+			    "is invalid in this context");
+		  return error_mark_node;
+		}
 	      string_tree = USERDEF_LITERAL_VALUE (tok->u.value);
 	      curr_type = cpp_userdef_string_remove_type (tok->type);
 	      curr_tok_is_userdef_p = true;
@@ -4608,7 +4618,7 @@ cp_parser_string_literal (cp_parser *parser, bool translate, bool wide_ok,
 	  tree literal = build_userdef_literal (suffix_id, value,
 						OT_NONE, NULL_TREE);
 	  if (lookup_udlit)
-	    value = cp_parser_userdef_string_literal (literal);
+	    value = finish_userdef_string_literal (literal);
 	  else
 	    value = literal;
 	}
@@ -4626,6 +4636,37 @@ cp_parser_string_literal (cp_parser *parser, bool translate, bool wide_ok,
   return cp_expr (value, loc);
 }
 
+/* Parse a sequence of adjacent string constants.  Return a TREE_STRING
+   representing the combined, nul-terminated string constant.  If
+   TRANSLATE is true, translate the string to the execution character set.
+   If WIDE_OK is true, a wide string is valid here.
+
+   This function issues an error if a user defined string literal is
+   encountered; use cp_parser_userdef_string_literal if UDLs are allowed.  */
+
+static inline cp_expr
+cp_parser_string_literal (cp_parser *parser, bool translate, bool wide_ok)
+{
+  return cp_parser_string_literal_common (parser, translate, wide_ok,
+					  /*udl_ok=*/false,
+					  /*lookup_udlit=*/false);
+}
+
+/* Parse a string literal or user defined string literal.
+
+   user-defined-string-literal :
+     string-literal ud-suffix
+
+   If LOOKUP_UDLIT, perform a lookup for a suitable template function.  */
+
+static inline cp_expr
+cp_parser_userdef_string_literal (cp_parser *parser, bool lookup_udlit)
+{
+  return cp_parser_string_literal_common (parser, /*translate=*/true,
+					  /*wide_ok=*/true, /*udl_ok=*/true,
+					  lookup_udlit);
+}
+
 /* Look up a literal operator with the name and the exact arguments.  */
 
 static tree
@@ -4923,7 +4964,7 @@ cp_parser_userdef_numeric_literal (cp_parser *parser)
    as arguments.  */
 
 static tree
-cp_parser_userdef_string_literal (tree literal)
+finish_userdef_string_literal (tree literal)
 {
   tree suffix_id = USERDEF_LITERAL_SUFFIX_ID (literal);
   tree name = cp_literal_operator_id (IDENTIFIER_POINTER (suffix_id));
@@ -5663,10 +5704,15 @@ cp_parser_primary_expression (cp_parser *parser,
       /* ??? Should wide strings be allowed when parser->translate_strings_p
 	 is false (i.e. in attributes)?  If not, we can kill the third
 	 argument to cp_parser_string_literal.  */
-      return (cp_parser_string_literal (parser,
-					parser->translate_strings_p,
-					true)
-	      .maybe_add_location_wrapper ());
+      if (parser->translate_strings_p)
+	return (cp_parser_userdef_string_literal (parser,
+						  /*lookup_udlit=*/true)
+		.maybe_add_location_wrapper ());
+      else
+	return (cp_parser_string_literal (parser,
+					  /*translate=*/false,
+					  /*wide_ok=*/true)
+		.maybe_add_location_wrapper ());
 
     case CPP_OPEN_PAREN:
       /* If we see `( { ' then we are looking at the beginning of
@@ -16222,15 +16268,14 @@ cp_parser_function_specifier_opt (cp_parser* parser,
 static void
 cp_parser_linkage_specification (cp_parser* parser, tree prefix_attr)
 {
-  tree linkage;
-
   /* Look for the `extern' keyword.  */
   cp_token *extern_token
     = cp_parser_require_keyword (parser, RID_EXTERN, RT_EXTERN);
 
   /* Look for the string-literal.  */
   cp_token *string_token = cp_lexer_peek_token (parser->lexer);
-  linkage = cp_parser_string_literal (parser, false, false);
+  tree linkage = cp_parser_string_literal (parser, /*translate=*/false,
+					   /*wide_ok=*/false);
 
   /* Transform the literal into an identifier.  If the literal is a
      wide-character string, or contains embedded NULs, then we can't
@@ -16360,9 +16405,8 @@ cp_parser_static_assert(cp_parser *parser, bool member_p)
       cp_parser_require (parser, CPP_COMMA, RT_COMMA);
 
       /* Parse the string-literal message.  */
-      message = cp_parser_string_literal (parser,
-                                	  /*translate=*/false,
-                                	  /*wide_ok=*/true);
+      message = cp_parser_string_literal (parser, /*translate=*/false,
+					  /*wide_ok=*/true);
 
       /* A `)' completes the static assertion.  */
       if (!parens.require_close (parser))
@@ -17410,7 +17454,6 @@ cp_parser_operator (cp_parser* parser, location_t start_loc)
     case CPP_STRING16_USERDEF:
     case CPP_STRING32_USERDEF:
       {
-	cp_expr str;
 	tree string_tree;
 	int sz, len;
 
@@ -17418,8 +17461,8 @@ cp_parser_operator (cp_parser* parser, location_t start_loc)
 	  maybe_warn_cpp0x (CPP0X_USER_DEFINED_LITERALS);
 
 	/* Consume the string.  */
-	str = cp_parser_string_literal (parser, /*translate=*/true,
-				      /*wide_ok=*/true, /*lookup_udlit=*/false);
+	cp_expr str = cp_parser_userdef_string_literal (parser,
+							/*lookup_udlit=*/false);
 	if (str == error_mark_node)
 	  return error_mark_node;
 	else if (TREE_CODE (str) == USERDEF_LITERAL)
@@ -22072,7 +22115,6 @@ cp_parser_using_directive (cp_parser* parser)
 static void
 cp_parser_asm_definition (cp_parser* parser)
 {
-  tree string;
   tree outputs = NULL_TREE;
   tree inputs = NULL_TREE;
   tree clobbers = NULL_TREE;
@@ -22180,7 +22222,8 @@ cp_parser_asm_definition (cp_parser* parser)
   if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
     return;
   /* Look for the string.  */
-  string = cp_parser_string_literal (parser, false, false);
+  tree string = cp_parser_string_literal (parser, /*translate=*/false,
+					  /*wide_ok=*/false);
   if (string == error_mark_node)
     {
       cp_parser_skip_to_closing_parenthesis (parser, true, false,
@@ -28655,11 +28698,8 @@ cp_parser_yield_expression (cp_parser* parser)
 static tree
 cp_parser_asm_specification_opt (cp_parser* parser)
 {
-  cp_token *token;
-  tree asm_specification;
-
   /* Peek at the next token.  */
-  token = cp_lexer_peek_token (parser->lexer);
+  cp_token *token = cp_lexer_peek_token (parser->lexer);
   /* If the next token isn't the `asm' keyword, then there's no
      asm-specification.  */
   if (!cp_parser_is_keyword (token, RID_ASM))
@@ -28672,7 +28712,9 @@ cp_parser_asm_specification_opt (cp_parser* parser)
   parens.require_open (parser);
 
   /* Look for the string-literal.  */
-  asm_specification = cp_parser_string_literal (parser, false, false);
+  tree asm_specification = cp_parser_string_literal (parser,
+						     /*translate=*/false,
+						     /*wide_ok=*/false);
 
   /* Look for the `)'.  */
   parens.require_close (parser);
@@ -28705,8 +28747,6 @@ cp_parser_asm_operand_list (cp_parser* parser)
 
   while (true)
     {
-      tree string_literal;
-      tree expression;
       tree name;
 
       if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
@@ -28724,13 +28764,15 @@ cp_parser_asm_operand_list (cp_parser* parser)
       else
 	name = NULL_TREE;
       /* Look for the string-literal.  */
-      string_literal = cp_parser_string_literal (parser, false, false);
+      tree string_literal = cp_parser_string_literal (parser,
+						      /*translate=*/false,
+						      /*wide_ok=*/false);
 
       /* Look for the `('.  */
       matching_parens parens;
       parens.require_open (parser);
       /* Parse the expression.  */
-      expression = cp_parser_expression (parser);
+      tree expression = cp_parser_expression (parser);
       /* Look for the `)'.  */
       parens.require_close (parser);
 
@@ -28770,10 +28812,10 @@ cp_parser_asm_clobber_list (cp_parser* parser)
 
   while (true)
     {
-      tree string_literal;
-
       /* Look for the string literal.  */
-      string_literal = cp_parser_string_literal (parser, false, false);
+      tree string_literal = cp_parser_string_literal (parser,
+						      /*translate=*/false,
+						      /*wide_ok=*/false);
       /* Add it to the list.  */
       clobbers = tree_cons (NULL_TREE, string_literal, clobbers);
       /* If the next token is not a `,', then the list is
@@ -43039,6 +43081,7 @@ cp_convert_omp_range_for (tree &this_pre_body, vec<tree, va_gc> *for_block,
 {
   tree begin, end, range_temp_decl = NULL_TREE;
   tree iter_type, begin_expr, end_expr;
+  bool clear_has_value_expr = false;
 
   if (processing_template_decl)
     {
@@ -43185,6 +43228,8 @@ cp_convert_omp_range_for (tree &this_pre_body, vec<tree, va_gc> *for_block,
 	      ++processing_template_decl;
 	      cp_finish_decomp (orig_decl, decomp_first_name, decomp_cnt);
 	      --processing_template_decl;
+	      if (!processing_template_decl)
+		clear_has_value_expr = true;
 	    }
 	}
     }
@@ -43193,8 +43238,20 @@ cp_convert_omp_range_for (tree &this_pre_body, vec<tree, va_gc> *for_block,
   TREE_VEC_ELT (v, 0) = range_temp_decl;
   TREE_VEC_ELT (v, 1) = end;
   TREE_VEC_ELT (v, 2) = orig_decl;
+  if (clear_has_value_expr)
+    TREE_PUBLIC (v) = 1;
   for (unsigned i = 0; i < decomp_cnt; i++)
     {
+      if (clear_has_value_expr)
+	{
+	  /* If cp_finish_decomp was called with processing_template_decl
+	     temporarily set to 1, then decomp names will have deduced
+	     name but the DECL_VALUE_EXPR will be dependent.  Hide those
+	     from folding of other loop initializers e.g. for warning
+	     purposes until cp_finish_omp_range_for.  */
+	  gcc_checking_assert (DECL_HAS_VALUE_EXPR_P (decomp_first_name));
+	  DECL_HAS_VALUE_EXPR_P (decomp_first_name) = 0;
+	}
       TREE_VEC_ELT (v, i + 3) = decomp_first_name;
       decomp_first_name = DECL_CHAIN (decomp_first_name);
     }
@@ -43217,6 +43274,18 @@ cp_finish_omp_range_for (tree orig, tree begin)
     {
       decomp_first_name = TREE_VEC_ELT (TREE_CHAIN (orig), 3);
       decomp_cnt = TREE_VEC_LENGTH (TREE_CHAIN (orig)) - 3;
+      if (TREE_PUBLIC (TREE_CHAIN (orig)))
+	{
+	  /* Undo temporary clearing of DECL_HAS_VALUE_EXPR_P done
+	     by cp_convert_omp_range_for above.  */
+	  TREE_PUBLIC (TREE_CHAIN (orig)) = 0;
+	  tree d = decomp_first_name;
+	  for (unsigned i = 0; i < decomp_cnt; i++)
+	    {
+	      DECL_HAS_VALUE_EXPR_P (d) = 1;
+	      d = DECL_CHAIN (d);
+	    }
+	}
       cp_maybe_mangle_decomp (decl, decomp_first_name, decomp_cnt);
     }
 
@@ -46345,7 +46414,9 @@ cp_parser_omp_context_selector (cp_parser *parser, tree set, bool has_parms_p)
 		      cp_lexer_consume_token (parser->lexer);
 		    }
 		  else if (cp_lexer_next_token_is (parser->lexer, CPP_STRING))
-		    value = cp_parser_string_literal (parser, false, false);
+		    value = cp_parser_string_literal (parser,
+						      /*translate=*/false,
+						      /*wide_ok=*/false);
 		  else
 		    {
 		      cp_parser_error (parser, "expected identifier or "
@@ -49367,7 +49438,8 @@ pragma_lex (tree *value, location_t *loc)
   if (ret == CPP_PRAGMA_EOL)
     ret = CPP_EOF;
   else if (ret == CPP_STRING)
-    *value = cp_parser_string_literal (the_parser, false, false);
+    *value = cp_parser_string_literal (the_parser, /*translate=*/false,
+				       /*wide_ok=*/false);
   else
     {
       if (ret == CPP_KEYWORD)
diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc
index 2a4d03c..51fc246 100644
--- a/gcc/cp/pt.cc
+++ b/gcc/cp/pt.cc
@@ -14306,6 +14306,11 @@ tsubst_function_decl (tree t, tree args, tsubst_flags_t complain,
   tree ctx = closure ? closure : DECL_CONTEXT (t);
   bool member = ctx && TYPE_P (ctx);
 
+  /* If this is a static lambda, remove the 'this' pointer added in
+     tsubst_lambda_expr now that we know the closure type.  */
+  if (lambda_fntype && DECL_STATIC_FUNCTION_P (t))
+    lambda_fntype = static_fn_type (lambda_fntype);
+
   if (member && !closure)
     ctx = tsubst_aggr_type (ctx, args,
 			    complain, t, /*entering_scope=*/1);
diff --git a/gcc/cp/tree.cc b/gcc/cp/tree.cc
index 8060d39..c1da868 100644
--- a/gcc/cp/tree.cc
+++ b/gcc/cp/tree.cc
@@ -3693,14 +3693,20 @@ build_min_non_dep_op_overload (enum tree_code op,
 {
   va_list p;
   int nargs, expected_nargs;
-  tree fn, call;
+  tree fn, call, obj = NULL_TREE;
 
   non_dep = extract_call_expr (non_dep);
 
   nargs = call_expr_nargs (non_dep);
 
   expected_nargs = cp_tree_code_length (op);
-  if (TREE_CODE (TREE_TYPE (overload)) == METHOD_TYPE)
+  if (TREE_CODE (TREE_TYPE (overload)) == METHOD_TYPE
+      /* For ARRAY_REF, operator[] is either a non-static member or newly
+	 static member, never out of class and for the static member case
+	 if user uses single index the operator[] needs to have a single
+	 argument as well, but the function is called with 2 - the object
+	 it is invoked on and the index.  */
+      || op == ARRAY_REF)
     expected_nargs -= 1;
   if ((op == POSTINCREMENT_EXPR
        || op == POSTDECREMENT_EXPR)
@@ -3715,6 +3721,8 @@ build_min_non_dep_op_overload (enum tree_code op,
   if (TREE_CODE (TREE_TYPE (overload)) == FUNCTION_TYPE)
     {
       fn = overload;
+      if (op == ARRAY_REF)
+	obj = va_arg (p, tree);
       for (int i = 0; i < nargs; i++)
 	{
 	  tree arg = va_arg (p, tree);
@@ -3746,6 +3754,8 @@ build_min_non_dep_op_overload (enum tree_code op,
   CALL_EXPR_ORDERED_ARGS (call_expr) = CALL_EXPR_ORDERED_ARGS (non_dep);
   CALL_EXPR_REVERSE_ARGS (call_expr) = CALL_EXPR_REVERSE_ARGS (non_dep);
 
+  if (obj)
+    return keep_unused_object_arg (call, obj, overload);
   return call;
 }
 
@@ -3759,11 +3769,15 @@ build_min_non_dep_op_overload (tree non_dep, tree overload, tree object,
   non_dep = extract_call_expr (non_dep);
 
   unsigned int nargs = call_expr_nargs (non_dep);
-  gcc_assert (TREE_CODE (TREE_TYPE (overload)) == METHOD_TYPE);
-  tree binfo = TYPE_BINFO (TREE_TYPE (object));
-  tree method = build_baselink (binfo, binfo, overload, NULL_TREE);
-  tree fn = build_min (COMPONENT_REF, TREE_TYPE (overload),
-		       object, method, NULL_TREE);
+  tree fn = overload;
+  if (TREE_CODE (TREE_TYPE (overload)) == METHOD_TYPE)
+    {
+      tree binfo = TYPE_BINFO (TREE_TYPE (object));
+      tree method = build_baselink (binfo, binfo, overload, NULL_TREE);
+      fn = build_min (COMPONENT_REF, TREE_TYPE (overload),
+		      object, method, NULL_TREE);
+      object = NULL_TREE;
+    }
   gcc_assert (vec_safe_length (args) == nargs);
 
   tree call = build_min_non_dep_call_vec (non_dep, fn, args);
@@ -3774,6 +3788,8 @@ build_min_non_dep_op_overload (tree non_dep, tree overload, tree object,
   CALL_EXPR_ORDERED_ARGS (call_expr) = CALL_EXPR_ORDERED_ARGS (non_dep);
   CALL_EXPR_REVERSE_ARGS (call_expr) = CALL_EXPR_REVERSE_ARGS (non_dep);
 
+  if (object)
+    return keep_unused_object_arg (call, object, overload);
   return call;
 }
 
diff --git a/gcc/doc/contrib.texi b/gcc/doc/contrib.texi
index 7e9c16f..758805d 100644
--- a/gcc/doc/contrib.texi
+++ b/gcc/doc/contrib.texi
@@ -635,6 +635,10 @@ and unit testing.
 Bob Manson for his behind the scenes work on dejagnu.
 
 @item
+Jose E. Marchesi for contributing the eBPF backend and his ongoing
+work maintaining it.
+
+@item
 John Marino for contributing the DragonFly BSD port.
 
 @item
diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi
index 0e2abe5..5a026c4 100644
--- a/gcc/doc/extend.texi
+++ b/gcc/doc/extend.texi
@@ -688,7 +688,7 @@ myprintf (FILE *f, const char *format, ...)
 @end smallexample
 @end deftypefn
 
-@deftypefn {Built-in Function} {size_t} __builtin_va_arg_pack_len ()
+@deftypefn {Built-in Function} {int} __builtin_va_arg_pack_len ()
 This built-in function returns the number of anonymous arguments of
 an inline function.  It can be used only in inline functions that
 are always inlined, never compiled as a separate function, such
@@ -1578,7 +1578,7 @@ locates data in flash but
 accesses to these data read from generic address space, i.e.@:
 from RAM,
 so that you need special accessors like @code{pgm_read_byte}
-from @w{@uref{http://nongnu.org/avr-libc/user-manual/,AVR-LibC}}
+from @w{@uref{https://www.nongnu.org/avr-libc/user-manual/,AVR-LibC}}
 together with attribute @code{progmem}.
 
 @noindent
@@ -10402,8 +10402,10 @@ ensures that modifying @var{a} does not affect the address referenced by
 is undefined if @var{a} is modified before using @var{b}.
 
 @code{asm} supports operand modifiers on operands (for example @samp{%k2} 
-instead of simply @samp{%2}). Typically these qualifiers are hardware 
-dependent. The list of supported modifiers for x86 is found at 
+instead of simply @samp{%2}). @ref{GenericOperandmodifiers,
+Generic Operand modifiers} lists the modifiers that are available
+on all targets.  Other modifiers are hardware dependent.
+For example, the list of supported modifiers for x86 is found at
 @ref{x86Operandmodifiers,x86 Operand modifiers}.
 
 If the C code that follows the @code{asm} makes no use of any of the output 
@@ -10671,8 +10673,10 @@ optimizers may discard the @code{asm} statement as unneeded
 (see @ref{Volatile}).
 
 @code{asm} supports operand modifiers on operands (for example @samp{%k2} 
-instead of simply @samp{%2}). Typically these qualifiers are hardware 
-dependent. The list of supported modifiers for x86 is found at 
+instead of simply @samp{%2}). @ref{GenericOperandmodifiers,
+Generic Operand modifiers} lists the modifiers that are available
+on all targets.  Other modifiers are hardware dependent.
+For example, the list of supported modifiers for x86 is found at
 @ref{x86Operandmodifiers,x86 Operand modifiers}.
 
 In this example using the fictitious @code{combine} instruction, the 
@@ -11024,6 +11028,30 @@ lab:
 @}
 @end example
 
+@anchor{GenericOperandmodifiers}
+@subsubsection Generic Operand Modifiers
+@noindent
+The following table shows the modifiers supported by all targets and their effects:
+
+@multitable {Modifier} {Description} {Example}
+@headitem Modifier @tab Description @tab Example
+@item @code{c}
+@tab Require a constant operand and print the constant expression with no punctuation.
+@tab @code{%c0}
+@item @code{n}
+@tab Like @samp{%c} except that the value of the constant is negated before printing.
+@tab @code{%n0}
+@item @code{a}
+@tab Substitute a memory reference, with the actual operand treated as the address.
+This may be useful when outputting a ``load address'' instruction, because
+often the assembler syntax for such an instruction requires you to write the
+operand as if it were a memory reference.
+@tab @code{%a0}
+@item @code{l}
+@tab Print the label name with no punctuation.
+@tab @code{%l0}
+@end multitable
+
 @anchor{x86Operandmodifiers}
 @subsubsection x86 Operand Modifiers
 
@@ -11374,6 +11402,21 @@ constant.  Used to select the specified bit position.
 @item @code{x} @tab Equivialent to @code{X}, but only for pointers.
 @end multitable
 
+@anchor{loongarchOperandmodifiers}
+@subsubsection LoongArch Operand Modifiers
+
+The list below describes the supported modifiers and their effects for LoongArch.
+
+@multitable @columnfractions .10 .90
+@headitem Modifier @tab Description
+@item @code{d} @tab Same as @code{c}.
+@item @code{i} @tab Print the character ''@code{i}'' if the operand is not a register.
+@item @code{m} @tab Same as @code{c}, but the printed value is @code{operand - 1}.
+@item @code{X} @tab Print a constant integer operand in hexadecimal.
+@item @code{z} @tab Print the operand in its unmodified form, followed by a comma.
+@end multitable
+
+
 @lowersections
 @include md.texi
 @raisesections
diff --git a/gcc/doc/include/fdl.texi b/gcc/doc/include/fdl.texi
index e2bcdfd..af1a9c1 100644
--- a/gcc/doc/include/fdl.texi
+++ b/gcc/doc/include/fdl.texi
@@ -7,7 +7,7 @@ gpl(7), fsf-funding(7).
 @c man end
 @c man begin COPYRIGHT
 Copyright @copyright{} 2000, 2001, 2002, 2007, 2008 Free Software Foundation, Inc.
-@uref{https://fsf.org/}
+@uref{https://www.fsf.org}
 
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.
@@ -46,7 +46,7 @@ of this license document, but changing it is not allowed.
 
 @display
 Copyright @copyright{} 2000, 2001, 2002, 2007, 2008 Free Software Foundation, Inc.
-@uref{https://fsf.org/}
+@uref{https://www.fsf.org}
 
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.
diff --git a/gcc/doc/install.texi b/gcc/doc/install.texi
index ccc8d15..b1861a6 100644
--- a/gcc/doc/install.texi
+++ b/gcc/doc/install.texi
@@ -3855,7 +3855,7 @@ Instead of GNU Binutils, you will need to install LLVM 13.0.1, or later, and cop
 @file{bin/llvm-ar} to both @file{bin/amdgcn-amdhsa-ar} and
 @file{bin/amdgcn-amdhsa-ranlib}.
 
-Use Newlib (3.2.0, or newer).
+Use Newlib (4.3.0 or newer).
 
 To run the binaries, install the HSA Runtime from the
 @uref{https://rocm.github.io,,ROCm Platform}, and use
@@ -4672,7 +4672,7 @@ Instead of GNU binutils, you will need to install
 Tell GCC where to find it:
 @option{--with-build-time-tools=[install-nvptx-tools]/nvptx-none/bin}.
 
-You will need newlib 3.1.0 or later.  It can be
+You will need newlib 4.3.0 or later.  It can be
 automatically built together with GCC@.  For this, add a symbolic link
 to nvptx-newlib's @file{newlib} directory to the directory containing
 the GCC sources.
diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi
index 631c005..d12f318 100644
--- a/gcc/doc/invoke.texi
+++ b/gcc/doc/invoke.texi
@@ -850,7 +850,9 @@ Objective-C and Objective-C++ Dialects}.
 -mcmse @gol
 -mfix-cmse-cve-2021-35465 @gol
 -mstack-protector-guard=@var{guard} -mstack-protector-guard-offset=@var{offset} @gol
--mfdpic}
+-mfdpic @gol
+-mbranch-protection=@var{none}|@var{standard}|@var{pac-ret}[+@var{leaf}]
+[+@var{bti}]|@var{bti}[+@var{pac-ret}[+@var{leaf}]]}
 
 @emph{AVR Options}
 @gccoptlist{-mmcu=@var{mcu}  -mabsdata  -maccumulate-args @gol
@@ -16561,7 +16563,7 @@ this can be achieved with @samp{setarch `uname -m` -R ./prog}.
 @item -fsanitize=kernel-address
 @opindex fsanitize=kernel-address
 Enable AddressSanitizer for Linux kernel.
-See @uref{https://github.com/google/kasan} for more details.
+See @uref{https://github.com/google/kernel-sanitizers} for more details.
 
 @item -fsanitize=hwaddress
 @opindex fsanitize=hwaddress
@@ -17694,8 +17696,9 @@ needs to build supplementary stub code for constructors to work.  On
 multi-libbed systems, @samp{gcc -shared} must select the correct support
 libraries to link against.  Failing to supply the correct flags may lead
 to subtle defects.  Supplying them in cases where they are not necessary
-is innocuous. For x86, crtfastmath.o will not be added when
-@option{-shared} is specified. }
+is innocuous.  @option{-shared} suppresses the addition of startup code
+to alter the floating-point environment as done with @option{-ffast-math},
+@option{-Ofast} or @option{-funsafe-math-optimizations} on some targets.}
 
 @item -shared-libgcc
 @itemx -static-libgcc
@@ -22020,6 +22023,9 @@ Disable the floating-point extension.
 @item +cdecp0, +cdecp1, ... , +cdecp7
 Enable the Custom Datapath Extension (CDE) on selected coprocessors according
 to the numbers given in the options in the range 0 to 7.
+
+@item +pacbti
+Enable the Pointer Authentication and Branch Target Identification Extension.
 @end table
 
 @item  armv8-m.main
@@ -22092,8 +22098,8 @@ Permissible names are: @samp{arm7tdmi}, @samp{arm7tdmi-s}, @samp{arm710t},
 @samp{cortex-r7}, @samp{cortex-r8}, @samp{cortex-r52}, @samp{cortex-r52plus},
 @samp{cortex-m0}, @samp{cortex-m0plus}, @samp{cortex-m1}, @samp{cortex-m3},
 @samp{cortex-m4}, @samp{cortex-m7}, @samp{cortex-m23}, @samp{cortex-m33},
-@samp{cortex-m35p}, @samp{cortex-m55}, @samp{cortex-x1}, @samp{cortex-x1c},
-@samp{cortex-m1.small-multiply}, @samp{cortex-m0.small-multiply},
+@samp{cortex-m35p}, @samp{cortex-m55}, @samp{cortex-m85}, @samp{cortex-x1},
+@samp{cortex-x1c}, @samp{cortex-m1.small-multiply}, @samp{cortex-m0.small-multiply},
 @samp{cortex-m0plus.small-multiply}, @samp{exynos-m1}, @samp{marvell-pj4},
 @samp{neoverse-n1}, @samp{neoverse-n2}, @samp{neoverse-v1}, @samp{xscale},
 @samp{iwmmxt}, @samp{iwmmxt2}, @samp{ep9312}, @samp{fa526}, @samp{fa626},
@@ -22157,17 +22163,22 @@ The following extension options are common to the listed CPUs:
 
 @table @samp
 @item +nodsp
-Disable the DSP instructions on @samp{cortex-m33}, @samp{cortex-m35p}
-and @samp{cortex-m55}. Also disable the M-Profile Vector Extension (MVE)
-integer and single precision floating-point instructions on @samp{cortex-m55}.
+Disable the DSP instructions on @samp{cortex-m33}, @samp{cortex-m35p},
+@samp{cortex-m55} and @samp{cortex-m85}. Also disable the M-Profile Vector
+Extension (MVE) integer and single precision floating-point instructions on
+@samp{cortex-m55} and @samp{cortex-m85}.
+
+@item +nopacbti
+Disable the Pointer Authentication and Branch Target Identification Extension
+on @samp{cortex-m85}.
 
 @item +nomve
 Disable the M-Profile Vector Extension (MVE) integer and single precision
-floating-point instructions on @samp{cortex-m55}.
+floating-point instructions on @samp{cortex-m55} and @samp{cortex-m85}.
 
 @item +nomve.fp
 Disable the M-Profile Vector Extension (MVE) single precision floating-point
-instructions on @samp{cortex-m55}.
+instructions on @samp{cortex-m55} and @samp{cortex-m85}.
 
 @item +cdecp0, +cdecp1, ... , +cdecp7
 Enable the Custom Datapath Extension (CDE) on selected coprocessors according
@@ -22179,7 +22190,8 @@ Disables the floating-point instructions on @samp{arm9e},
 @samp{arm1020e}, @samp{arm1022e}, @samp{arm926ej-s},
 @samp{arm1026ej-s}, @samp{cortex-r5}, @samp{cortex-r7}, @samp{cortex-r8},
 @samp{cortex-m4}, @samp{cortex-m7}, @samp{cortex-m33}, @samp{cortex-m35p}
-and @samp{cortex-m55}.
+@samp{cortex-m4}, @samp{cortex-m7}, @samp{cortex-m33}, @samp{cortex-m35p},
+@samp{cortex-m55} and @samp{cortex-m85}.
 Disables the floating-point and SIMD instructions on
 @samp{generic-armv7-a}, @samp{cortex-a5}, @samp{cortex-a7},
 @samp{cortex-a8}, @samp{cortex-a9}, @samp{cortex-a12},
@@ -22519,9 +22531,9 @@ Development Tools Engineering Specification", which can be found on
 Mitigate against a potential security issue with the @code{VLLDM} instruction
 in some M-profile devices when using CMSE (CVE-2021-365465).  This option is
 enabled by default when the option @option{-mcpu=} is used with
-@code{cortex-m33}, @code{cortex-m35p}, @code{cortex-m55} or @code{star-mc1}.
-The option @option{-mno-fix-cmse-cve-2021-35465} can be used to disable
-the mitigation.
+@code{cortex-m33}, @code{cortex-m35p}, @code{cortex-m55}, @code{cortex-m85}
+or @code{star-mc1}. The option @option{-mno-fix-cmse-cve-2021-35465} can be used
+to disable the mitigation.
 
 @item -mstack-protector-guard=@var{guard}
 @itemx -mstack-protector-guard-offset=@var{offset}
@@ -22553,6 +22565,39 @@ The opposite @option{-mno-fdpic} option is useful (and required) to
 build the Linux kernel using the same (@code{arm-*-uclinuxfdpiceabi})
 toolchain as the one used to build the userland programs.
 
+@item -mbranch-protection=@var{none}|@var{standard}|@var{pac-ret}[+@var{leaf}][+@var{bti}]|@var{bti}[+@var{pac-ret}[+@var{leaf}]]
+@opindex mbranch-protection
+Enable branch protection features (armv8.1-m.main only).
+@samp{none} generate code without branch protection or return address
+signing.
+@samp{standard[+@var{leaf}]} generate code with all branch protection
+features enabled at their standard level.
+@samp{pac-ret[+@var{leaf}]} generate code with return address signing
+set to its standard level, which is to sign all functions that save
+the return address to memory.
+@samp{leaf} When return address signing is enabled, also sign leaf
+functions even if they do not write the return address to memory.
++@samp{bti} Add landing-pad instructions at the permitted targets of
+indirect branch instructions.
+
+If the @samp{+pacbti} architecture extension is not enabled, then all
+branch protection and return address signing operations are
+constrained to use only the instructions defined in the
+architectural-NOP space. The generated code will remain
+backwards-compatible with earlier versions of the architecture, but
+the additional security can be enabled at run time on processors that
+support the @samp{PACBTI} extension.
+
+Branch target enforcement using BTI can only be enabled at runtime if
+all code in the application has been compiled with at least
+@samp{-mbranch-protection=bti}.
+
+Any setting other than @samp{none} is supported only on armv8-m.main
+or later.
+
+The default is to generate code without branch protection or return
+address signing.
+
 @end table
 
 @node AVR Options
@@ -32291,7 +32336,7 @@ AES, CLFLUSHOPT, XSAVEC, XSAVES, SGX, AVX512F, AVX512VL, AVX512BW, AVX512DQ,
 AVX512CD, PKU, AVX512VBMI, AVX512IFMA, SHA, AVX512VNNI, GFNI, VAES, AVX512VBMI2,
 VPCLMULQDQ, AVX512BITALG, RDPID, AVX512VPOPCNTDQ, PCONFIG, WBNOINVD, CLWB,
 MOVDIRI, MOVDIR64B, ENQCMD, CLDEMOTE, PTWRITE, WAITPKG, SERIALIZE, TSXLDTRK,
-UINTR, AMX-BF16, AMX-TILE, AMX-INT8, AVX-VNNI, AVX512FP16 and AVX512BF16
+UINTR, AMX-BF16, AMX-TILE, AMX-INT8, AVX-VNNI, AVX512-FP16 and AVX512BF16
 instruction set support.
 
 @item alderlake
@@ -32318,7 +32363,7 @@ AES, CLFLUSHOPT, XSAVEC, XSAVES, SGX, AVX512F, AVX512VL, AVX512BW, AVX512DQ,
 AVX512CD, PKU, AVX512VBMI, AVX512IFMA, SHA, AVX512VNNI, GFNI, VAES, AVX512VBMI2,
 VPCLMULQDQ, AVX512BITALG, RDPID, AVX512VPOPCNTDQ, PCONFIG, WBNOINVD, CLWB,
 MOVDIRI, MOVDIR64B, AVX512VP2INTERSECT, ENQCMD, CLDEMOTE, PTWRITE, WAITPKG,
-SERIALIZE, TSXLDTRK, UINTR, AMX-BF16, AMX-TILE, AMX-INT8, AVX-VNNI, AVX512FP16,
+SERIALIZE, TSXLDTRK, UINTR, AMX-BF16, AMX-TILE, AMX-INT8, AVX-VNNI, AVX512-FP16,
 AVX512BF16, AMX-FP16 and PREFETCHI instruction set support.
 
 @item k6
@@ -33184,7 +33229,7 @@ WBNOINVD, FMA4, PREFETCHW, RDPID, PREFETCHWT1, RDSEED, SGX, XOP, LWP,
 XSAVEOPT, XSAVEC, XSAVES, RTM, HLE, TBM, MWAITX, CLZERO, PKU, AVX512VBMI2,
 GFNI, VAES, WAITPKG, VPCLMULQDQ, AVX512BITALG, MOVDIRI, MOVDIR64B, AVX512BF16,
 ENQCMD, AVX512VPOPCNTDQ, AVX5124FMAPS, AVX512VNNI, AVX5124VNNIW, SERIALIZE,
-UINTR, HRESET, AMXTILE, AMXINT8, AMXBF16, KL, WIDEKL, AVXVNNI, AVX512FP16,
+UINTR, HRESET, AMXTILE, AMXINT8, AMXBF16, KL, WIDEKL, AVXVNNI, AVX512-FP16,
 AVXIFMA, AVXVNNIINT8, AVXNECONVERT, CMPCCXADD, AMX-FP16, PREFETCHI, RAOINT or
 CLDEMOTE extended instruction sets. Each has a corresponding @option{-mno-}
 option to disable use of these instructions.
diff --git a/gcc/doc/lto.texi b/gcc/doc/lto.texi
index e591e8d..eb5f54b 100644
--- a/gcc/doc/lto.texi
+++ b/gcc/doc/lto.texi
@@ -170,13 +170,11 @@ object files.  This is used at link time to determine the optimization
 level and other settings when they are not explicitly specified at the
 linker command line.
 
-Currently, GCC does not support combining LTO object files compiled
-with different set of the command line options into a single binary.
-At link time, the options given on the command line and the options
-saved on all the files in a link-time set are applied globally.  No
-attempt is made at validating the combination of flags (other than the
-usual validation done by option processing).  This is implemented in
-@file{lto/lto.cc}:@code{lto_read_all_file_options}.
+Most options are recorded at a per function level and their setting
+restored when processing the functions at link time.  Global options
+are composed from options specified at compile time and link time.
+How exactly they are combined or mismatches diagnosed is implemented in
+@file{lto-wrapper.cc}:@code{find_and_merge_options}.
 
 
 @item Symbol table (@code{.gnu.lto_.symtab})
diff --git a/gcc/doc/options.texi b/gcc/doc/options.texi
index c6e73fd..f50063c 100644
--- a/gcc/doc/options.texi
+++ b/gcc/doc/options.texi
@@ -161,7 +161,7 @@ the help text to use for @option{--help} (omitted if the second field
 contains the @code{Undocumented} property).
 @end enumerate
 
-By default, all options beginning with ``f'', ``W'' or ``m'' are
+By default, all options beginning with ``f'', ``g'', ``W'' or ``m'' are
 implicitly assumed to take a ``no-'' form.  This form should not be
 listed separately.  If an option beginning with one of these letters
 does not have a ``no-'' form, you can use the @code{RejectNegative}
@@ -239,8 +239,8 @@ and should not be accepted by the driver.
 
 @item RejectNegative
 The option does not have a ``no-'' form.  All options beginning with
-``f'', ``W'' or ``m'' are assumed to have a ``no-'' form unless this
-property is used.
+``f'', ``g'', ``W'' or ``m'' are assumed to have a ``no-'' form unless
+this property is used.
 
 @item Negative(@var{othername})
 The option will turn off another option @var{othername}, which is
diff --git a/gcc/doc/sourcebuild.texi b/gcc/doc/sourcebuild.texi
index e605707..df54526 100644
--- a/gcc/doc/sourcebuild.texi
+++ b/gcc/doc/sourcebuild.texi
@@ -73,10 +73,10 @@ The runtime support library for atomic operations (e.g.@: for @code{__sync}
 and @code{__atomic}).
 
 @item libbacktrace
-A library that allows gcc to produce backtraces when it crashes.
+A library that allows GCC to produce backtraces when it crashes.
 
 @item libcc1
-A library that allows gdb to make use of the compiler.
+A library that allows GDB to make use of the compiler.
 
 @item libcody
 A compiler dynamism library to allow communication between compilers and
@@ -2195,6 +2195,10 @@ ARM target supports options to generate instructions from ARMv8.1-M with
 the Custom Datapath Extension (CDE) and M-Profile Vector Extension (MVE).
 Some multilibs may be incompatible with these options.
 
+@item arm_pacbti_hw
+Test system supports executing Pointer Authentication and Branch Target
+Identification instructions.
+
 @item arm_prefer_ldrd_strd
 ARM target prefers @code{LDRD} and @code{STRD} instructions over
 @code{LDM} and @code{STM} instructions.
@@ -2284,6 +2288,12 @@ ARM target generates Thumb-2 code for @code{-mthumb} but does not
 support executing the Armv8.1-M Mainline Low Overhead Loop
 instructions @code{DLS} and @code{LE}.
 
+@item mbranch_protection_ok
+ARM target supporting @code{-mbranch-protection=standard}.
+
+@item arm_pacbti_hw
+Test system supports for executing non nop pacbti instructions.
+
 @end table
 
 @subsubsection AArch64-specific attributes
diff --git a/gcc/doc/standards.texi b/gcc/doc/standards.texi
index d9ee11c..2bcb664 100644
--- a/gcc/doc/standards.texi
+++ b/gcc/doc/standards.texi
@@ -280,7 +280,7 @@ works with the Apple/NeXT Objective-C runtime library.
 There is no formal written standard for Objective-C or Objective-C++@.
 The authoritative manual on traditional Objective-C (1.0) is
 ``Object-Oriented Programming and the Objective-C Language'':
-@uref{http://www.gnustep.org/@/resources/@/documentation/@/ObjectivCBook.pdf}
+@uref{https://gnustep.github.io/@/resources/@/documentation/@/ObjectivCBook.pdf}
 is the original NeXTstep document.
 
 The Objective-C exception and synchronization syntax (that is, the
@@ -318,7 +318,7 @@ available online, see @uref{https://gcc.gnu.org/readings.html}
 @section Go Language
 
 As of the GCC 4.7.1 release, GCC supports the Go 1 language standard,
-described at @uref{https://golang.org/doc/go1}.
+described at @uref{https://go.dev/doc/go1}.
 
 @section D language
 
diff --git a/gcc/dominance.cc b/gcc/dominance.cc
index 13d5498..099b8fd 100644
--- a/gcc/dominance.cc
+++ b/gcc/dominance.cc
@@ -705,10 +705,12 @@ compute_dom_fast_query_in_region (enum cdi_direction dir,
 }
 
 /* The main entry point into this module.  DIR is set depending on whether
-   we want to compute dominators or postdominators.  */
+   we want to compute dominators or postdominators.  If COMPUTE_FAST_QUERY
+   is false then the DFS numbers allowing for a O(1) dominance query
+   are not computed.  */
 
 void
-calculate_dominance_info (cdi_direction dir)
+calculate_dominance_info (cdi_direction dir, bool compute_fast_query)
 {
   unsigned int dir_index = dom_convert_dir_to_idx (dir);
 
@@ -745,7 +747,8 @@ calculate_dominance_info (cdi_direction dir)
   else
     checking_verify_dominators (dir);
 
-  compute_dom_fast_query (dir);
+  if (compute_fast_query)
+    compute_dom_fast_query (dir);
 
   timevar_pop (TV_DOMINANCE);
 }
diff --git a/gcc/dominance.h b/gcc/dominance.h
index abdcf76..3c5a345 100644
--- a/gcc/dominance.h
+++ b/gcc/dominance.h
@@ -35,7 +35,7 @@ enum dom_state
   DOM_OK		/* Everything is ok.  */
 };
 
-extern void calculate_dominance_info (enum cdi_direction);
+extern void calculate_dominance_info (enum cdi_direction, bool = true);
 extern void calculate_dominance_info_for_region (enum cdi_direction,
 						 vec<basic_block>);
 extern void free_dominance_info (function *, enum cdi_direction);
diff --git a/gcc/fortran/ChangeLog b/gcc/fortran/ChangeLog
index 5e6feea..d1a481b 100644
--- a/gcc/fortran/ChangeLog
+++ b/gcc/fortran/ChangeLog
@@ -1,3 +1,93 @@
+2023-01-29  Mikael Morin  <mikael@gcc.gnu.org>
+
+	PR fortran/108450
+	* check.cc (gfc_check_minloc_maxloc): Explicitly set argument name.
+	(gfc_check_findloc): Ditto.
+
+2023-01-29  Jerry DeLisle  <jvdelisle@gcc.gnu.org>
+
+	PR fortran/103506
+	* parse.cc (parse_module): Remove use of a bool error value
+	that prevented proper setting of the namespace pointer.
+
+2023-01-28  Harald Anlauf  <anlauf@gmx.de>
+	    Steven G. Kargl  <kargl@gcc.gnu.org>
+
+	PR fortran/108527
+	* resolve.cc (compare_bound_int): Expression to compare must be of
+	type INTEGER.
+	(compare_bound_mpz_t): Likewise.
+	(check_dimension): Fix comment on checks applied to array section
+	and clean up associated logic.
+
+2023-01-28  Harald Anlauf  <anlauf@gmx.de>
+
+	PR fortran/108453
+	* match.cc (gfc_match_common): A USE associated name shall not appear
+	in a COMMON block (F2018:C8121).
+
+2023-01-27  Tobias Burnus  <tobias@codesourcery.com>
+
+	PR fortran/108558
+	* trans-openmp.cc (gfc_split_omp_clauses): Handle has_device_addr.
+
+2023-01-26  Harald Anlauf  <anlauf@gmx.de>
+
+	PR fortran/108544
+	* resolve.cc (check_host_association): Extend host association check
+	so that it is not restricted to functions.  Also prevent NULL pointer
+	dereference.
+
+2023-01-25  Steve Kargl  <kargl@gcc.gnu.org>
+
+	PR fortran/108528
+	* array.cc (compare_bounds): Return false instead of generating an
+	internal error on an invalid argument type.
+
+2023-01-24  Harald Anlauf  <anlauf@gmx.de>
+
+	PR fortran/108529
+	* simplify.cc (simplify_transformation): Do not try to simplify
+	transformational intrinsic when the ARRAY argument has a NULL shape.
+
+2023-01-23  Harald Anlauf  <anlauf@gmx.de>
+
+	PR fortran/108502
+	* dependency.cc (gfc_check_dependency): Prevent NULL pointer
+	dereference while recursively checking expressions.
+
+2023-01-23  Harald Anlauf  <anlauf@gmx.de>
+
+	PR fortran/108501
+	* interface.cc (get_expr_storage_size): Check array subscript triplets
+	that we actually have integer values before trying to extract with
+	mpz_get_si.
+
+2023-01-23  Harald Anlauf  <anlauf@gmx.de>
+
+	PR fortran/108420
+	* iresolve.cc (check_charlen_present): Preserve character length if
+	there is no array constructor.
+
+2023-01-21  Jerry DeLisle  <jvdelisle@gcc.gnu.org>
+
+	PR fortran/102595
+	* data.cc (gfc_assign_data_value): Remove check for PARAMETER in DATA.
+	* primary.cc (match_variable): Add check for PARAMETER in DATA.
+
+2023-01-19  Harald Anlauf  <anlauf@gmx.de>
+
+	PR fortran/108434
+	* expr.cc (class_allocatable): Prevent NULL pointer dereference
+	or invalid read.
+	(class_pointer): Likewise.
+
+2023-01-17  Harald Anlauf  <anlauf@gmx.de>
+
+	PR fortran/108421
+	* interface.cc (get_expr_storage_size): Check that we actually have
+	an integer value before trying to extract it with mpz_get_si.
+
 2023-01-12  Tobias Burnus  <tobias@codesourcery.com>
 
 	PR fortran/107706
diff --git a/gcc/fortran/ChangeLog-2022 b/gcc/fortran/ChangeLog-2022
index 71e551d..253af76 100644
--- a/gcc/fortran/ChangeLog-2022
+++ b/gcc/fortran/ChangeLog-2022
@@ -1,6 +1,6 @@
 2022-12-30  Steve Kargl  <kargl@gcc.gnu.org>
 
-	PR fortran/102595
+	PR fortran/102331
 	* decl.cc (attr_decl1): Guard against NULL pointer.
 	* parse.cc (match_deferred_characteristics): Include BT_CLASS in check for
 	derived being undefined.
diff --git a/gcc/fortran/array.cc b/gcc/fortran/array.cc
index e8a2c32..be5eb8b 100644
--- a/gcc/fortran/array.cc
+++ b/gcc/fortran/array.cc
@@ -967,7 +967,7 @@ gfc_copy_array_spec (gfc_array_spec *src)
 
 
 /* Returns nonzero if the two expressions are equal.
-   We should not need to support more than constant values, as that’s what is
+   We should not need to support more than constant values, as that's what is
    allowed in derived type component array spec.  However, we may create types
    with non-constant array spec for dummy variable class container types, for
    which the _data component holds the array spec of the variable declaration.
@@ -979,7 +979,7 @@ compare_bounds (gfc_expr *bound1, gfc_expr *bound2)
   if (bound1 == NULL || bound2 == NULL
       || bound1->ts.type != BT_INTEGER
       || bound2->ts.type != BT_INTEGER)
-    gfc_internal_error ("gfc_compare_array_spec(): Array spec clobbered");
+    return false;
 
   /* What qualifies as identical bounds?  We could probably just check that the
      expressions are exact clones.  We avoid rewriting a specific comparison
diff --git a/gcc/fortran/check.cc b/gcc/fortran/check.cc
index ebcb8f3..8c1ae8c 100644
--- a/gcc/fortran/check.cc
+++ b/gcc/fortran/check.cc
@@ -3888,6 +3888,7 @@ gfc_check_minloc_maxloc (gfc_actual_arglist *ap)
     {
       b = gfc_get_logical_expr (gfc_logical_4_kind, NULL, 0);
       ap->next->next->next->next->expr = b;
+      ap->next->next->next->next->name = gfc_get_string ("back");
     }
 
   if (m == NULL && d != NULL && d->ts.type == BT_LOGICAL
@@ -3969,6 +3970,7 @@ gfc_check_findloc (gfc_actual_arglist *ap)
     {
       b = gfc_get_logical_expr (gfc_logical_4_kind, NULL, 0);
       ap->next->next->next->next->next->expr = b;
+      ap->next->next->next->next->next->name = gfc_get_string ("back");
     }
 
   if (m == NULL && d != NULL && d->ts.type == BT_LOGICAL
diff --git a/gcc/fortran/data.cc b/gcc/fortran/data.cc
index 443d35d..d29eb12 100644
--- a/gcc/fortran/data.cc
+++ b/gcc/fortran/data.cc
@@ -244,13 +244,6 @@ gfc_assign_data_value (gfc_expr *lvalue, gfc_expr *rvalue, mpz_t index,
 		    "array-element nor a scalar-structure-component";
 
   symbol = lvalue->symtree->n.sym;
-  if (symbol->attr.flavor == FL_PARAMETER)
-    {
-      gfc_error ("PARAMETER %qs shall not appear in a DATA statement at %L",
-		 symbol->name, &lvalue->where);
-      return false;
-    }
-
   init = symbol->value;
   last_ts = &symbol->ts;
   last_con = NULL;
diff --git a/gcc/fortran/dependency.cc b/gcc/fortran/dependency.cc
index 43417a6..9117825 100644
--- a/gcc/fortran/dependency.cc
+++ b/gcc/fortran/dependency.cc
@@ -1292,6 +1292,11 @@ gfc_check_dependency (gfc_expr *expr1, gfc_expr *expr2, bool identical)
   if (expr1->expr_type != EXPR_VARIABLE)
     gfc_internal_error ("gfc_check_dependency: expecting an EXPR_VARIABLE");
 
+  /* Prevent NULL pointer dereference while recursively analyzing invalid
+     expressions.  */
+  if (expr2 == NULL)
+    return 0;
+
   switch (expr2->expr_type)
     {
     case EXPR_OP:
diff --git a/gcc/fortran/expr.cc b/gcc/fortran/expr.cc
index 5ec369c..3036b1b 100644
--- a/gcc/fortran/expr.cc
+++ b/gcc/fortran/expr.cc
@@ -4996,14 +4996,14 @@ get_union_initializer (gfc_symbol *union_type, gfc_component **map_p)
 static bool
 class_allocatable (gfc_component *comp)
 {
-  return comp->ts.type == BT_CLASS && CLASS_DATA (comp)
+  return comp->ts.type == BT_CLASS && comp->attr.class_ok && CLASS_DATA (comp)
     && CLASS_DATA (comp)->attr.allocatable;
 }
 
 static bool
 class_pointer (gfc_component *comp)
 {
-  return comp->ts.type == BT_CLASS && CLASS_DATA (comp)
+  return comp->ts.type == BT_CLASS && comp->attr.class_ok && CLASS_DATA (comp)
     && CLASS_DATA (comp)->attr.pointer;
 }
 
diff --git a/gcc/fortran/interface.cc b/gcc/fortran/interface.cc
index c4f7faa..dafe417 100644
--- a/gcc/fortran/interface.cc
+++ b/gcc/fortran/interface.cc
@@ -2858,7 +2858,8 @@ get_expr_storage_size (gfc_expr *e)
   if (e->ts.type == BT_CHARACTER)
     {
       if (e->ts.u.cl && e->ts.u.cl->length
-          && e->ts.u.cl->length->expr_type == EXPR_CONSTANT)
+	  && e->ts.u.cl->length->expr_type == EXPR_CONSTANT
+	  && e->ts.u.cl->length->ts.type == BT_INTEGER)
 	strlen = mpz_get_si (e->ts.u.cl->length->value.integer);
       else if (e->expr_type == EXPR_CONSTANT
 	       && (e->ts.u.cl == NULL || e->ts.u.cl->length == NULL))
@@ -2909,7 +2910,8 @@ get_expr_storage_size (gfc_expr *e)
 
 	    if (ref->u.ar.stride[i])
 	      {
-		if (ref->u.ar.stride[i]->expr_type == EXPR_CONSTANT)
+		if (ref->u.ar.stride[i]->expr_type == EXPR_CONSTANT
+		    && ref->u.ar.stride[i]->ts.type == BT_INTEGER)
 		  stride = mpz_get_si (ref->u.ar.stride[i]->value.integer);
 		else
 		  return 0;
@@ -2917,26 +2919,30 @@ get_expr_storage_size (gfc_expr *e)
 
 	    if (ref->u.ar.start[i])
 	      {
-		if (ref->u.ar.start[i]->expr_type == EXPR_CONSTANT)
+		if (ref->u.ar.start[i]->expr_type == EXPR_CONSTANT
+		    && ref->u.ar.start[i]->ts.type == BT_INTEGER)
 		  start = mpz_get_si (ref->u.ar.start[i]->value.integer);
 		else
 		  return 0;
 	      }
 	    else if (ref->u.ar.as->lower[i]
-		     && ref->u.ar.as->lower[i]->expr_type == EXPR_CONSTANT)
+		     && ref->u.ar.as->lower[i]->expr_type == EXPR_CONSTANT
+		     && ref->u.ar.as->lower[i]->ts.type == BT_INTEGER)
 	      start = mpz_get_si (ref->u.ar.as->lower[i]->value.integer);
 	    else
 	      return 0;
 
 	    if (ref->u.ar.end[i])
 	      {
-		if (ref->u.ar.end[i]->expr_type == EXPR_CONSTANT)
+		if (ref->u.ar.end[i]->expr_type == EXPR_CONSTANT
+		    && ref->u.ar.end[i]->ts.type == BT_INTEGER)
 		  end = mpz_get_si (ref->u.ar.end[i]->value.integer);
 		else
 		  return 0;
 	      }
 	    else if (ref->u.ar.as->upper[i]
-		     && ref->u.ar.as->upper[i]->expr_type == EXPR_CONSTANT)
+		     && ref->u.ar.as->upper[i]->expr_type == EXPR_CONSTANT
+		     && ref->u.ar.as->upper[i]->ts.type == BT_INTEGER)
 	      end = mpz_get_si (ref->u.ar.as->upper[i]->value.integer);
 	    else
 	      return 0;
@@ -2977,7 +2983,9 @@ get_expr_storage_size (gfc_expr *e)
 		  || ref->u.ar.as->upper[i] == NULL
 		  || ref->u.ar.as->lower[i] == NULL
 		  || ref->u.ar.as->upper[i]->expr_type != EXPR_CONSTANT
-		  || ref->u.ar.as->lower[i]->expr_type != EXPR_CONSTANT)
+		  || ref->u.ar.as->lower[i]->expr_type != EXPR_CONSTANT
+		  || ref->u.ar.as->upper[i]->ts.type != BT_INTEGER
+		  || ref->u.ar.as->lower[i]->ts.type != BT_INTEGER)
 		return 0;
 
 	      elements
@@ -2999,7 +3007,9 @@ get_expr_storage_size (gfc_expr *e)
 	    {
 	      if (!as->upper[i] || !as->lower[i]
 		  || as->upper[i]->expr_type != EXPR_CONSTANT
-		  || as->lower[i]->expr_type != EXPR_CONSTANT)
+		  || as->lower[i]->expr_type != EXPR_CONSTANT
+		  || as->upper[i]->ts.type != BT_INTEGER
+		  || as->lower[i]->ts.type != BT_INTEGER)
 		return 0;
 
 	      elements = elements
diff --git a/gcc/fortran/iresolve.cc b/gcc/fortran/iresolve.cc
index 711e917..33794f0 100644
--- a/gcc/fortran/iresolve.cc
+++ b/gcc/fortran/iresolve.cc
@@ -94,9 +94,12 @@ check_charlen_present (gfc_expr *source)
   else if (source->expr_type == EXPR_ARRAY)
     {
       gfc_constructor *c = gfc_constructor_first (source->value.constructor);
-      source->ts.u.cl->length
-		= gfc_get_int_expr (gfc_charlen_int_kind, NULL,
-				    c->expr->value.character.length);
+      if (c)
+	source->ts.u.cl->length
+	  = gfc_get_int_expr (gfc_charlen_int_kind, NULL,
+			      c->expr->value.character.length);
+      if (source->ts.u.cl->length == NULL)
+	gfc_internal_error ("check_charlen_present(): length not set");
     }
 }
 
diff --git a/gcc/fortran/match.cc b/gcc/fortran/match.cc
index 5e933c1..5eb6d0e 100644
--- a/gcc/fortran/match.cc
+++ b/gcc/fortran/match.cc
@@ -5345,6 +5345,16 @@ gfc_match_common (void)
 		goto cleanup;
 	    }
 
+	  /* F2018:R874:  common-block-object is variable-name [ (array-spec) ]
+	     F2018:C8121: A variable-name shall not be a name made accessible
+	     by use association.  */
+	  if (sym->attr.use_assoc)
+	    {
+	      gfc_error ("Symbol %qs at %C is USE associated from module %qs "
+			 "and cannot occur in COMMON", sym->name, sym->module);
+	      goto cleanup;
+	    }
+
 	  /* Deal with an optional array specification after the
 	     symbol name.  */
 	  m = gfc_match_array_spec (&as, true, true);
diff --git a/gcc/fortran/parse.cc b/gcc/fortran/parse.cc
index 0fb19cc..039e7e7 100644
--- a/gcc/fortran/parse.cc
+++ b/gcc/fortran/parse.cc
@@ -6502,7 +6502,6 @@ parse_module (void)
 {
   gfc_statement st;
   gfc_gsymbol *s;
-  bool error;
 
   s = gfc_get_gsymbol (gfc_new_block->name, false);
   if (s->defined || (s->type != GSYM_UNKNOWN && s->type != GSYM_MODULE))
@@ -6525,7 +6524,6 @@ parse_module (void)
 
   st = parse_spec (ST_NONE);
 
-  error = false;
 loop:
   switch (st)
     {
@@ -6544,16 +6542,11 @@ loop:
     default:
       gfc_error ("Unexpected %s statement in MODULE at %C",
 		 gfc_ascii_statement (st));
-
-      error = true;
       reject_statement ();
       st = next_statement ();
       goto loop;
     }
-
-  /* Make sure not to free the namespace twice on error.  */
-  if (!error)
-    s->ns = gfc_current_ns;
+  s->ns = gfc_current_ns;
 }
 
 
diff --git a/gcc/fortran/primary.cc b/gcc/fortran/primary.cc
index 543d9cc..28ce5fe 100644
--- a/gcc/fortran/primary.cc
+++ b/gcc/fortran/primary.cc
@@ -4076,8 +4076,14 @@ match_variable (gfc_expr **result, int equiv_flag, int host_flag)
 	  gfc_error ("Named constant at %C in an EQUIVALENCE");
 	  return MATCH_ERROR;
 	}
-      /* Otherwise this is checked for and an error given in the
-	 variable definition context checks.  */
+      if (gfc_in_match_data())
+	{
+	  gfc_error ("PARAMETER %qs shall not appear in a DATA statement at %C",
+		      sym->name);
+	  return MATCH_ERROR;
+	}
+	/* Otherwise this is checked for an error given in the
+	   variable definition context checks.  */
       break;
 
     case FL_PROCEDURE:
diff --git a/gcc/fortran/resolve.cc b/gcc/fortran/resolve.cc
index 94213cd..100b238 100644
--- a/gcc/fortran/resolve.cc
+++ b/gcc/fortran/resolve.cc
@@ -4575,12 +4575,11 @@ compare_bound_int (gfc_expr *a, int b)
 {
   int i;
 
-  if (a == NULL || a->expr_type != EXPR_CONSTANT)
+  if (a == NULL
+      || a->expr_type != EXPR_CONSTANT
+      || a->ts.type != BT_INTEGER)
     return CMP_UNKNOWN;
 
-  if (a->ts.type != BT_INTEGER)
-    gfc_internal_error ("compare_bound_int(): Bad expression");
-
   i = mpz_cmp_si (a->value.integer, b);
 
   if (i < 0)
@@ -4598,12 +4597,11 @@ compare_bound_mpz_t (gfc_expr *a, mpz_t b)
 {
   int i;
 
-  if (a == NULL || a->expr_type != EXPR_CONSTANT)
+  if (a == NULL
+      || a->expr_type != EXPR_CONSTANT
+      || a->ts.type != BT_INTEGER)
     return CMP_UNKNOWN;
 
-  if (a->ts.type != BT_INTEGER)
-    gfc_internal_error ("compare_bound_int(): Bad expression");
-
   i = mpz_cmp (a->value.integer, b);
 
   if (i < 0)
@@ -4733,23 +4731,24 @@ check_dimension (int i, gfc_array_ref *ar, gfc_array_spec *as)
 #define AR_END (ar->end[i] ? ar->end[i] : as->upper[i])
 
 	compare_result comp_start_end = compare_bound (AR_START, AR_END);
+	compare_result comp_stride_zero = compare_bound_int (ar->stride[i], 0);
 
 	/* Check for zero stride, which is not allowed.  */
-	if (compare_bound_int (ar->stride[i], 0) == CMP_EQ)
+	if (comp_stride_zero == CMP_EQ)
 	  {
 	    gfc_error ("Illegal stride of zero at %L", &ar->c_where[i]);
 	    return false;
 	  }
 
-	/* if start == len || (stride > 0 && start < len)
-			   || (stride < 0 && start > len),
+	/* if start == end || (stride > 0 && start < end)
+			   || (stride < 0 && start > end),
 	   then the array section contains at least one element.  In this
 	   case, there is an out-of-bounds access if
 	   (start < lower || start > upper).  */
-	if (compare_bound (AR_START, AR_END) == CMP_EQ
-	    || ((compare_bound_int (ar->stride[i], 0) == CMP_GT
-		 || ar->stride[i] == NULL) && comp_start_end == CMP_LT)
-	    || (compare_bound_int (ar->stride[i], 0) == CMP_LT
+	if (comp_start_end == CMP_EQ
+	    || ((comp_stride_zero == CMP_GT || ar->stride[i] == NULL)
+		&& comp_start_end == CMP_LT)
+	    || (comp_stride_zero == CMP_LT
 	        && comp_start_end == CMP_GT))
 	  {
 	    if (compare_bound (AR_START, as->lower[i]) == CMP_LT)
@@ -6087,7 +6086,6 @@ check_host_association (gfc_expr *e)
       gfc_find_symbol (e->symtree->name, gfc_current_ns, 1, &sym);
 
       if (sym && old_sym != sym
-	      && sym->ts.type == old_sym->ts.type
 	      && sym->attr.flavor == FL_PROCEDURE
 	      && sym->attr.contained)
 	{
@@ -6132,6 +6130,9 @@ check_host_association (gfc_expr *e)
 		  return false;
 		}
 
+	      if (ref == NULL)
+		return false;
+
 	      gcc_assert (ref->type == REF_ARRAY);
 
 	      /* Grab the start expressions from the array ref and
diff --git a/gcc/fortran/simplify.cc b/gcc/fortran/simplify.cc
index f413f13..20ea38e 100644
--- a/gcc/fortran/simplify.cc
+++ b/gcc/fortran/simplify.cc
@@ -720,6 +720,7 @@ simplify_transformation (gfc_expr *array, gfc_expr *dim, gfc_expr *mask,
   size_zero = gfc_is_size_zero_array (array);
 
   if (!(is_constant_array_expr (array) || size_zero)
+      || array->shape == NULL
       || !gfc_is_constant_expr (dim))
     return NULL;
 
diff --git a/gcc/fortran/trans-openmp.cc b/gcc/fortran/trans-openmp.cc
index 87213de..5283d0c 100644
--- a/gcc/fortran/trans-openmp.cc
+++ b/gcc/fortran/trans-openmp.cc
@@ -6205,6 +6205,8 @@ gfc_split_omp_clauses (gfc_code *code,
 	    = code->ext.omp_clauses->lists[OMP_LIST_MAP];
 	  clausesa[GFC_OMP_SPLIT_TARGET].lists[OMP_LIST_IS_DEVICE_PTR]
 	    = code->ext.omp_clauses->lists[OMP_LIST_IS_DEVICE_PTR];
+	  clausesa[GFC_OMP_SPLIT_TARGET].lists[OMP_LIST_HAS_DEVICE_ADDR]
+	    = code->ext.omp_clauses->lists[OMP_LIST_HAS_DEVICE_ADDR];
 	  clausesa[GFC_OMP_SPLIT_TARGET].device
 	    = code->ext.omp_clauses->device;
 	  clausesa[GFC_OMP_SPLIT_TARGET].thread_limit
diff --git a/gcc/function-tests.cc b/gcc/function-tests.cc
index 846226d..39970b2 100644
--- a/gcc/function-tests.cc
+++ b/gcc/function-tests.cc
@@ -583,6 +583,7 @@ test_ranges ()
   push_cfun (fun);
   range_tests ();
   range_op_tests ();
+  relation_tests ();
 
   build_cfg (fndecl);
   convert_to_ssa (fndecl);
diff --git a/gcc/gcc.cc b/gcc/gcc.cc
index d629ca5..d813002 100644
--- a/gcc/gcc.cc
+++ b/gcc/gcc.cc
@@ -1423,6 +1423,7 @@ static const struct compiler default_compilers[] =
   {".r", "#Ratfor", 0, 0, 0},
   {".go", "#Go", 0, 1, 0},
   {".d", "#D", 0, 1, 0}, {".dd", "#D", 0, 1, 0}, {".di", "#D", 0, 1, 0},
+  {".mod", "#Modula-2", 0, 0, 0}, {".m2i", "#Modula-2", 0, 0, 0},
   /* Next come the entries for C.  */
   {".c", "@c", 0, 0, 1},
   {"@c",
diff --git a/gcc/genmatch.cc b/gcc/genmatch.cc
index d4cb439..e147ab9 100644
--- a/gcc/genmatch.cc
+++ b/gcc/genmatch.cc
@@ -489,6 +489,21 @@ commutative_op (id_base *id)
       case CFN_FNMS:
 	return 0;
 
+      case CFN_COND_ADD:
+      case CFN_COND_MUL:
+      case CFN_COND_MIN:
+      case CFN_COND_MAX:
+      case CFN_COND_FMIN:
+      case CFN_COND_FMAX:
+      case CFN_COND_AND:
+      case CFN_COND_IOR:
+      case CFN_COND_XOR:
+      case CFN_COND_FMA:
+      case CFN_COND_FMS:
+      case CFN_COND_FNMA:
+      case CFN_COND_FNMS:
+	return 1;
+
       default:
 	return -1;
       }
diff --git a/gcc/gimple-predicate-analysis.cc b/gcc/gimple-predicate-analysis.cc
index a7719ff..094e8c7 100644
--- a/gcc/gimple-predicate-analysis.cc
+++ b/gcc/gimple-predicate-analysis.cc
@@ -728,11 +728,11 @@ value_sat_pred_p (tree val, tree boundary, tree_code cmpc,
   if (cmpc != BIT_AND_EXPR)
     return is_value_included_in (val, boundary, cmpc);
 
-  wide_int andw = wi::to_wide (val) & wi::to_wide (boundary);
+  widest_int andw = wi::to_widest (val) & wi::to_widest (boundary);
   if (exact_p)
-    return andw == wi::to_wide (val);
+    return andw == wi::to_widest (val);
 
-  return andw.to_uhwi ();
+  return wi::ne_p (andw, 0);
 }
 
 /* Return true if the domain of single predicate expression PRED1
diff --git a/gcc/gimple-range-fold.cc b/gcc/gimple-range-fold.cc
index 91eb629..9c5359a 100644
--- a/gcc/gimple-range-fold.cc
+++ b/gcc/gimple-range-fold.cc
@@ -1039,6 +1039,9 @@ fold_using_range::relation_fold_and_or (irange& lhs_range, gimple *s,
   if (!ssa1_dep1 || !ssa1_dep2 || !ssa2_dep1 || !ssa2_dep2)
     return;
 
+  if (HONOR_NANS (TREE_TYPE (ssa1_dep1)))
+    return;
+
   // Make sure they are the same dependencies, and detect the order of the
   // relationship.
   bool reverse_op2 = true;
diff --git a/gcc/gimple-ssa-store-merging.cc b/gcc/gimple-ssa-store-merging.cc
index 5a477c4..df7afd2 100644
--- a/gcc/gimple-ssa-store-merging.cc
+++ b/gcc/gimple-ssa-store-merging.cc
@@ -1614,7 +1614,7 @@ namespace {
    then VAL represents the constant and all the other fields are zero, or
    a memory load, then VAL represents the reference, BASE_ADDR is non-NULL
    and the other fields also reflect the memory load, or an SSA name, then
-   VAL represents the SSA name and all the other fields are zero,  */
+   VAL represents the SSA name and all the other fields are zero.  */
 
 class store_operand_info
 {
@@ -2309,6 +2309,10 @@ merged_store_group::apply_stores ()
   if (buf_size <= MOVE_MAX)
     string_concatenation = false;
 
+  /* String concatenation only works for byte aligned start and end.  */
+  if (start % BITS_PER_UNIT != 0 || width % BITS_PER_UNIT != 0)
+    string_concatenation = false;
+
   /* Create a power-of-2-sized buffer for native_encode_expr.  */
   if (!string_concatenation)
     buf_size = 1 << ceil_log2 (buf_size);
@@ -3631,7 +3635,7 @@ split_group (merged_store_group *group, bool allow_unaligned_store,
 
   /* For bswap framework using sets of stores, all the checking has been done
      earlier in try_coalesce_bswap and the result always needs to be emitted
-     as a single store.  Likewise for string concatenation,  */
+     as a single store.  Likewise for string concatenation.  */
   if (group->stores[0]->rhs_code == LROTATE_EXPR
       || group->stores[0]->rhs_code == NOP_EXPR
       || group->string_concatenation)
diff --git a/gcc/ginclude/unwind-arm-common.h b/gcc/ginclude/unwind-arm-common.h
index a2ef868..3ee0a6b 100644
--- a/gcc/ginclude/unwind-arm-common.h
+++ b/gcc/ginclude/unwind-arm-common.h
@@ -127,7 +127,8 @@ extern "C" {
       _UVRSC_VFP = 1,       /* vfp */
       _UVRSC_FPA = 2,       /* fpa */
       _UVRSC_WMMXD = 3,     /* Intel WMMX data register */
-      _UVRSC_WMMXC = 4      /* Intel WMMX control register */
+      _UVRSC_WMMXC = 4,     /* Intel WMMX control register */
+      _UVRSC_PAC = 5        /* Armv8.1-M Mainline PAC/AUTH pseudo-register */
     }
   _Unwind_VRS_RegClass;
 
diff --git a/gcc/go/ChangeLog b/gcc/go/ChangeLog
index bd03955..a4173f4 100644
--- a/gcc/go/ChangeLog
+++ b/gcc/go/ChangeLog
@@ -1,3 +1,9 @@
+2023-01-17  Ian Lance Taylor  <iant@golang.org>
+
+	PR go/108426
+	* go-gcc.cc (Gcc_backend::Gcc_backend): Define __builtin_ctzl and
+	__builtin_clzl.  Patch by Andrew Pinski.
+
 2023-01-02  Jakub Jelinek  <jakub@redhat.com>
 
 	* gccgo.texi: Bump @copyrights-go year.
diff --git a/gcc/go/go-gcc.cc b/gcc/go/go-gcc.cc
index a4a0e5d..07c34a5 100644
--- a/gcc/go/go-gcc.cc
+++ b/gcc/go/go-gcc.cc
@@ -627,6 +627,11 @@ Gcc_backend::Gcc_backend()
 						unsigned_type_node,
 						NULL_TREE),
 		       builtin_const);
+  this->define_builtin(BUILT_IN_CTZL, "__builtin_ctzl", "ctzl",
+		      build_function_type_list(integer_type_node,
+					       long_unsigned_type_node,
+					       NULL_TREE),
+		      builtin_const);
   this->define_builtin(BUILT_IN_CTZLL, "__builtin_ctzll", "ctzll",
 		       build_function_type_list(integer_type_node,
 						long_long_unsigned_type_node,
@@ -637,6 +642,11 @@ Gcc_backend::Gcc_backend()
 						unsigned_type_node,
 						NULL_TREE),
 		       builtin_const);
+  this->define_builtin(BUILT_IN_CLZL, "__builtin_clzl", "clzl",
+		      build_function_type_list(integer_type_node,
+					       long_unsigned_type_node,
+					       NULL_TREE),
+		      builtin_const);
   this->define_builtin(BUILT_IN_CLZLL, "__builtin_clzll", "clzll",
 		       build_function_type_list(integer_type_node,
 						long_long_unsigned_type_node,
diff --git a/gcc/ipa-modref.cc b/gcc/ipa-modref.cc
index 16e8bfb..e3196df 100644
--- a/gcc/ipa-modref.cc
+++ b/gcc/ipa-modref.cc
@@ -1875,11 +1875,11 @@ modref_access_analysis::analyze ()
      statement cannot be analyzed (for any reason), the entire function cannot
      be analyzed by modref.  */
   basic_block bb;
+  bitmap always_executed_bbs = find_always_executed_bbs (cfun, true);
   FOR_EACH_BB_FN (bb, cfun)
     {
       gimple_stmt_iterator si;
-      bool always_executed
-	      = bb == single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun))->dest;
+      bool always_executed = bitmap_bit_p (always_executed_bbs, bb->index);
 
       for (si = gsi_start_nondebug_after_labels_bb (bb);
 	   !gsi_end_p (si); gsi_next_nondebug (&si))
@@ -1926,6 +1926,7 @@ modref_access_analysis::analyze ()
 	  && !finite_function_p ())
 	m_summary_lto->side_effects = true;
     }
+  BITMAP_FREE (always_executed_bbs);
 }
 
 /* Return true if OP accesses memory pointed to by SSA_NAME.  */
diff --git a/gcc/ipa-sra.cc b/gcc/ipa-sra.cc
index 4d7c25c..81b7591 100644
--- a/gcc/ipa-sra.cc
+++ b/gcc/ipa-sra.cc
@@ -2529,7 +2529,8 @@ process_scan_results (cgraph_node *node, struct function *fun,
      TODO: Measure the overhead and the effect of just being pessimistic.
      Maybe this is only -O3 material?  */
 
-  bool pdoms_calculated = false;
+  hash_map<gimple *, bool> analyzed_stmts;
+  bitmap always_executed_bbs = NULL;
   if (check_pass_throughs)
     for (cgraph_edge *cs = node->callees; cs; cs = cs->next_callee)
       {
@@ -2566,27 +2567,46 @@ process_scan_results (cgraph_node *node, struct function *fun,
 		continue;
 	      }
 
-	    /* Post-dominator check placed last, hoping that it usually won't
-	       be needed.  */
-	    if (!pdoms_calculated)
+	    /* Walk basic block and see if its execution can terminate earlier.
+	       Keep the info for later re-use to avoid quadratic behavoiur here.  */
+	    gimple_stmt_iterator gsi = gsi_for_stmt (call_stmt);
+	    bool safe = true;
+	    int n = 0;
+	    for (gsi_prev (&gsi); !gsi_end_p (gsi); gsi_prev (&gsi))
 	      {
-		gcc_checking_assert (cfun);
-		connect_infinite_loops_to_exit ();
-		calculate_dominance_info (CDI_POST_DOMINATORS);
-		pdoms_calculated = true;
+		bool *b = analyzed_stmts.get (gsi_stmt (gsi));
+		if (b)
+		  {
+		    safe = *b;
+		    gsi_next (&gsi);
+		    break;
+		  }
+		n++;
+		if (stmt_may_terminate_function_p (fun, gsi_stmt (gsi), false))
+		  {
+		    safe = false;
+		    break;
+		  }
 	      }
-	    if (dominated_by_p (CDI_POST_DOMINATORS,
-				gimple_bb (call_stmt),
-				single_succ (ENTRY_BLOCK_PTR_FOR_FN (fun))))
+	    if (n)
+	      {
+		if (gsi_end_p (gsi))
+		  gsi = gsi_start_bb (gimple_bb (call_stmt));
+		for (; gsi_stmt (gsi) != call_stmt; gsi_next (&gsi))
+		  analyzed_stmts.get_or_insert (gsi_stmt (gsi)) = safe;
+	      }
+
+	    if (safe && !always_executed_bbs)
+	      {
+		mark_dfs_back_edges ();
+		always_executed_bbs = find_always_executed_bbs (fun, false);
+	      }
+	    if (safe && bitmap_bit_p (always_executed_bbs, gimple_bb (call_stmt)->index))
 	      csum->m_arg_flow[argidx].safe_to_import_accesses = true;
 	  }
 
       }
-  if (pdoms_calculated)
-    {
-      free_dominance_info (CDI_POST_DOMINATORS);
-      remove_fake_exit_edges ();
-    }
+  BITMAP_FREE (always_executed_bbs);
 
   /* TODO: Add early exit if we disqualified everything.  This also requires
      that we either relax the restriction that
diff --git a/gcc/ipa-utils.cc b/gcc/ipa-utils.cc
index 163899a..8badcc2 100644
--- a/gcc/ipa-utils.cc
+++ b/gcc/ipa-utils.cc
@@ -35,6 +35,14 @@ along with GCC; see the file COPYING3.  If not see
 #include "tree-vrp.h"
 #include "ipa-prop.h"
 #include "ipa-fnsummary.h"
+#include "tree-eh.h"
+#include "gimple-iterator.h"
+#include "ipa-modref-tree.h"
+#include "ipa-modref.h"
+#include "tree-ssa-loop-niter.h"
+#include "calls.h"
+#include "cfgloop.h"
+#include "cfganal.h"
 
 /* Debugging function for postorder and inorder code. NOTE is a string
    that is printed before the nodes are printed.  ORDER is an array of
@@ -781,3 +789,258 @@ recursive_call_p (tree func, tree dest)
       return false;
   return true;
 }
+
+/* Return true if stmt may terminate execution of function.
+   If assume_return_or_eh we can further assume that the function ends
+   either by retrn statement or EH (no trapping or infinite loops).  */
+
+bool
+stmt_may_terminate_function_p (function *fun, gimple *stmt, bool assume_return_or_eh)
+{
+  if (stmt_can_throw_external (fun, stmt))
+    return true;
+  if (assume_return_or_eh)
+    return false;
+  gasm *astmt = dyn_cast <gasm *> (stmt);
+  if (astmt && gimple_asm_volatile_p (astmt))
+    return true;
+  if (gimple_could_trap_p (stmt))
+    return true;
+  if (gcall *call = dyn_cast <gcall *> (stmt))
+    {
+      int flags = gimple_call_flags (call);
+      if (flags & (ECF_PURE | ECF_CONST) && ! (flags & ECF_LOOPING_CONST_OR_PURE))
+	return false;
+      modref_summary *s = get_modref_function_summary (call, NULL);
+      if (s && !s->side_effects)
+	return false;
+      return true;
+    }
+  return false;
+}
+
+/* Return bitmap of all basic blocks whose first statements are known to
+   execute on every invocation of the function.
+
+   If assume_return_or_eh we can further assume that the function ends
+   either by retrn statement or EH (no trapping or infinite loops).
+   This is useful when sumarizing function in passes like ipa-modref.
+ 
+   Seeing assume_return_or_eh to false is used to prove that given
+   statmeent will be executed even if the function gets into infinite
+   loop or trap.  */
+bitmap
+find_always_executed_bbs (function *fun, bool assume_return_or_eh)
+{
+  auto_vec<basic_block, 20> stack;
+  auto_vec<basic_block, 20> terminating_bbs;
+  hash_set<basic_block> visited;
+  hash_set<basic_block> terminating_bbs_set;
+  edge e;
+  edge_iterator ei;
+  int flags = flags_from_decl_or_type (fun->decl);
+  /* PUre and const functions always return.  */
+  assume_return_or_eh |= (flags & (ECF_CONST|ECF_PURE)) && !(flags & ECF_LOOPING_CONST_OR_PURE);
+  if (!assume_return_or_eh)
+    mark_dfs_back_edges (fun);
+
+  /* First walk all BBs reachable from entry stopping on statements that may
+     terminate execution.  Everything past this statement is not going to be executed
+     each invocation.  */
+  stack.safe_push (ENTRY_BLOCK_PTR_FOR_FN (fun));
+  while (!stack.is_empty ())
+    {
+      basic_block bb = stack.pop ();
+      bool found = false, found_exit = false;
+      if (bb->index == EXIT_BLOCK)
+	continue;
+      FOR_EACH_EDGE (e, ei, bb->succs)
+	{
+	  if (e->dest == EXIT_BLOCK_PTR_FOR_FN (fun))
+	    {
+	      found_exit = true;
+	      break;
+	    }
+	  /* Watch for infinite loops.  */
+	  if (!found
+	      && !assume_return_or_eh && (e->flags & EDGE_DFS_BACK))
+	    {
+	      if (!dom_info_available_p (CDI_DOMINATORS))
+		calculate_dominance_info (CDI_DOMINATORS);
+	      /* If this is not a loop latch edge it is an irreducible region.
+		 Assume that it is infinite.
+		 TODO: with C++ forced progression we can still walk the
+		 irreducible region and see if it contains any side effects.
+		 Similarly for loops.  -ffinite-loops does not really imply
+		 this since we allow inlining across -ffinite-loops bondary
+		 and thus it can be used only as a loop flag.  */
+	      if (e->dest->loop_father->header != e->dest
+		  || !dominated_by_p (CDI_DOMINATORS, bb, e->dest))
+		found = true;
+	      else if (!finite_loop_p (e->dest->loop_father))
+		found = true;
+	    }
+	}
+      if (!assume_return_or_eh
+	  && (EDGE_COUNT (bb->succs) == 0 || (bb->flags & BB_IRREDUCIBLE_LOOP)))
+	found = true;
+      for (gimple_stmt_iterator si = gsi_start_nondebug_after_labels_bb (bb);
+	   !gsi_end_p (si) && !found; gsi_next_nondebug (&si))
+	if (stmt_may_terminate_function_p (fun, gsi_stmt (si), assume_return_or_eh))
+	  {
+	    found = true;
+	    break;
+	  }
+      if (found)
+	{
+	  visited.add (EXIT_BLOCK_PTR_FOR_FN (fun));
+	  if (!found_exit)
+	    {
+	      terminating_bbs.safe_push (bb);
+	      terminating_bbs_set.add (bb);
+	    }
+	}
+      else
+	FOR_EACH_EDGE (e, ei, bb->succs)
+	  if (!visited.add (e->dest))
+	    stack.safe_push (e->dest);
+    }
+
+  /* Next walk from exit block and find all articulations in the CFG.
+     Add all terminating basic blocks as "fake" predecessors of the
+     exit block.  */
+
+  bitmap ret = BITMAP_ALLOC (NULL);
+  /* A degenerated case when there is no path to exit.  */
+  if (!visited.contains (EXIT_BLOCK_PTR_FOR_FN (fun)))
+    {
+      bitmap_set_bit (ret,
+		      single_succ_edge
+		        (ENTRY_BLOCK_PTR_FOR_FN (fun))->dest->index);
+      return ret;
+    }
+
+  struct astate
+  {
+    unsigned int dfs_preorder;
+    unsigned int dfs_postorder;
+
+    unsigned int low, high;
+  };
+
+  struct worklist
+  {
+    basic_block bb;
+    astate *cstate;
+  };
+
+  struct obstack state_obstack;
+  gcc_obstack_init (&state_obstack);
+  hash_map<basic_block, astate *> state;
+  auto_vec<worklist, 32> worklist_vec;
+  unsigned int next_dfs_num = 1;
+
+  /* Always executed blocks are blocks that are on every path from entry to exit.
+     We proceed in two steps.  First we do backward DFS walk (so we know that entry
+     is always reached) and record preorder and postorder visiting times.
+
+     In second step we proceed in postorder and for every block A we compute
+     minimal preorder (A.low) and maximal postorder (A.high) of block reachable
+     from the BBs in DFS subtree of A.  If A is always executed there are no
+     edges out of this subtree.  This can be tested by checking that A.low == A.preorder
+     and B.high == A.postorder.
+    
+     This is first step. Do backward DFS walk and record preorder, postorder
+     and predecessor info.  Initialize stack in postorder.  */
+  worklist we = {EXIT_BLOCK_PTR_FOR_FN (fun), NULL};
+  worklist_vec.safe_push (we);
+  while (!worklist_vec.is_empty ())
+    {
+      worklist &w = worklist_vec.last ();
+      basic_block bb = w.bb;
+      astate *cstate = w.cstate;
+
+      if (!cstate)
+	{
+	  astate **slot = &state.get_or_insert (bb);
+
+	  cstate = *slot;
+	  /* Already processed by DFS?  */
+	  if (cstate)
+	    {
+	      worklist_vec.pop ();
+	      continue;
+	    }
+	  /* DFS is visiting BB for first time.  */
+	  *slot = cstate = XOBNEW (&state_obstack, struct astate);
+	  cstate->low = cstate->high = cstate->dfs_preorder = next_dfs_num++;
+	  w.cstate = cstate;
+	  /* Exit block is special; process all fake edges we identified.  */
+	  if (bb == EXIT_BLOCK_PTR_FOR_FN (fun))
+	    for (basic_block bb2 : terminating_bbs)
+	      {
+		worklist we = {bb2, NULL};
+		worklist_vec.safe_push (we);
+	      }
+	  FOR_EACH_EDGE (e, ei, bb->preds)
+	    if (visited.contains (e->src))
+	      {
+		worklist we = {e->src, NULL};
+		worklist_vec.safe_push (we);
+	      }
+	  /* Keep BB on worklist so we process it last time.  */
+	  continue;
+	}
+      /* We are finished with processing reachable BBs, see if we have articulation.  */
+      worklist_vec.pop ();
+      cstate->high = cstate->dfs_postorder = next_dfs_num++;
+      stack.safe_push (bb);
+    }
+  /* This is the final postorder walk.  Determine low and high values and mark
+     always executed blocks.  */
+  for (basic_block bb : stack)
+    {
+      astate *cstate = *state.get (bb);
+      FOR_EACH_EDGE (e, ei, bb->preds)
+	{
+	  astate **cstate2 = state.get (e->src);
+	  /* We skip walking part of CFG reached only after first edge to exit.
+	     No BB reachable from the skipped part is always executed */
+	  if (!cstate2)
+	    {
+	      if (e->src != ENTRY_BLOCK_PTR_FOR_FN (fun))
+		cstate->low = 0;
+	      continue;
+	    }
+	  cstate->low = MIN (cstate->low, (*cstate2)->low);
+	  cstate->high = MAX (cstate->high, (*cstate2)->high);
+	}
+      if (dump_file && (dump_flags & TDF_DETAILS) && bb != EXIT_BLOCK_PTR_FOR_FN (fun))
+	fprintf (dump_file, "BB %i %s preorder %i posorder %i low %i high %i\n",
+		 bb->index, terminating_bbs_set.contains (bb) ? "(terminating)": "",
+		 cstate->dfs_preorder, cstate->dfs_postorder, cstate->low, cstate->high);
+      if (cstate->low == cstate->dfs_preorder && cstate->high == cstate->dfs_postorder
+	  && bb != EXIT_BLOCK_PTR_FOR_FN (fun))
+	bitmap_set_bit (ret, bb->index);
+      if (terminating_bbs_set.contains (bb))
+	cstate->low = 0;
+      else
+	FOR_EACH_EDGE (e, ei, bb->succs)
+	  {
+	    astate **cstate2 = state.get (e->dest);
+	    if (!cstate2)
+	      continue;
+	    cstate->low = MIN (cstate->low, (*cstate2)->low);
+	    cstate->high = MAX (cstate->high, (*cstate2)->high);
+	  }
+      }
+  obstack_free (&state_obstack, NULL);
+  if (dump_file)
+    {
+      fprintf (dump_file, "Always executed bbbs %s: ",
+	       assume_return_or_eh ? "(assuming return or EH)": "");
+      bitmap_print (dump_file, ret, "", "\n");
+    }
+
+  return ret;
+}
diff --git a/gcc/ipa-utils.h b/gcc/ipa-utils.h
index e7322e1..0eefcf4 100644
--- a/gcc/ipa-utils.h
+++ b/gcc/ipa-utils.h
@@ -46,6 +46,8 @@ tree get_base_var (tree);
 void ipa_merge_profiles (struct cgraph_node *dst,
 			 struct cgraph_node *src, bool preserve_body = false);
 bool recursive_call_p (tree, tree);
+bool stmt_may_terminate_function_p (function *fun, gimple *stmt, bool assume_return_or_eh);
+bitmap find_always_executed_bbs (function *fun, bool assume_return_or_eh);
 
 /* In ipa-pure-const.cc  */
 bool finite_function_p ();
diff --git a/gcc/lra-constraints.cc b/gcc/lra-constraints.cc
index b0b3c5b..7bffbc0 100644
--- a/gcc/lra-constraints.cc
+++ b/gcc/lra-constraints.cc
@@ -184,12 +184,12 @@ get_try_hard_regno (int regno)
   return ira_class_hard_regs[rclass][0];
 }
 
-/* Return the hard regno of X after removing its subreg.  If X is not
-   a register or a subreg of a register, return -1.  If X is a pseudo,
-   use its assignment.  If FINAL_P return the final hard regno which will
-   be after elimination.  */
+/* Return the hard regno of X after removing its subreg.  If X is not a
+   register or a subreg of a register, return -1.  If X is a pseudo, use its
+   assignment.  If X is a hard regno, return the final hard regno which will be
+   after elimination.  */
 static int
-get_hard_regno (rtx x, bool final_p)
+get_hard_regno (rtx x)
 {
   rtx reg;
   int hard_regno;
@@ -203,7 +203,7 @@ get_hard_regno (rtx x, bool final_p)
     hard_regno = lra_get_regno_hard_regno (hard_regno);
   if (hard_regno < 0)
     return -1;
-  if (final_p)
+  if (HARD_REGISTER_NUM_P (REGNO (reg)))
     hard_regno = lra_get_elimination_hard_regno (hard_regno);
   if (SUBREG_P (x))
     hard_regno += subreg_regno_offset (hard_regno, GET_MODE (reg),
@@ -782,7 +782,7 @@ operands_match_p (rtx x, rtx y, int y_hard_regno)
     {
       int j;
 
-      i = get_hard_regno (x, false);
+      i = get_hard_regno (x);
       if (i < 0)
 	goto slow;
 
@@ -1920,7 +1920,7 @@ uses_hard_regs_p (rtx x, HARD_REG_SET set)
 
   if (REG_P (x) || SUBREG_P (x))
     {
-      x_hard_regno = get_hard_regno (x, true);
+      x_hard_regno = get_hard_regno (x);
       return (x_hard_regno >= 0
 	      && overlaps_hard_reg_set_p (set, mode, x_hard_regno));
     }
@@ -2078,7 +2078,7 @@ process_alt_operands (int only_alternative)
 
       op = no_subreg_reg_operand[nop] = *curr_id->operand_loc[nop];
       /* The real hard regno of the operand after the allocation.  */
-      hard_regno[nop] = get_hard_regno (op, true);
+      hard_regno[nop] = get_hard_regno (op);
 
       operand_reg[nop] = reg = op;
       biggest_mode[nop] = GET_MODE (op);
@@ -2258,7 +2258,7 @@ process_alt_operands (int only_alternative)
 			&& curr_operand_mode[m] != curr_operand_mode[nop])
 		      break;
 		    
-		    m_hregno = get_hard_regno (*curr_id->operand_loc[m], false);
+		    m_hregno = get_hard_regno (*curr_id->operand_loc[m]);
 		    /* We are supposed to match a previous operand.
 		       If we do, we win if that one did.  If we do
 		       not, count both of the operands as losers.
diff --git a/gcc/m2/ChangeLog b/gcc/m2/ChangeLog
index ab0f6dd..6e9bc21 100644
--- a/gcc/m2/ChangeLog
+++ b/gcc/m2/ChangeLog
@@ -1,3 +1,355 @@
+2023-01-28  Iain Sandoe  <iain@sandoe.co.uk>
+
+	* lang.opt: Claim Wreturn-type.
+
+2023-01-27  Gaius Mulley  <gaiusmod2@gmail.com>
+
+	* gm2-compiler/M2Comp.mod:  Import MetaString0.
+	(ExamineCompilationUnit): New variable Message.
+	Create and format error string.
+	* gm2-compiler/M2LexBuf.mod: New variable SeenEof.
+	(GetNonEofToken): New procedure.
+	(Init): Set SeenEof to FALSE.
+	(GetToken): Use GetNonEofToken instead of calls to
+	m2flex.GetToken and GetToken.
+	(AddTok): Detect eoftok and set SeenEof.
+
+2023-01-27  Gaius Mulley  <gaiusmod2@gmail.com>
+
+	* gm2-compiler/M2Options.def: Export GetMQ, SetMQ.
+	* gm2-compiler/M2Preprocess.mod: (MakeSaveTempsFileName):
+	Test NewDir against NIL.  Test Dumpdir against NIL.
+	Test GetMD () against NIL.  Test GetMMD () against NIL.
+	Test GetMQ () against NIL.  Test GetObj () against NIL.
+	Test tempfile against NIL.
+	* gm2-compiler/P2SymBuild.def: Export
+	BuildNoReturnAttribute.
+
+2023-01-27  Iain Sandoe  <iain@sandoe.co.uk>
+
+	PR modula2/108555
+	PR modula2/108182
+	PR modula2/102343
+	* gm2-lang.cc (gm2_langhook_option_lang_mask): Do not claim CL_C
+	or CL_DRIVER.
+	(gm2_langhook_init_options): Handle options that we want to pass
+	to the preprocessor.
+	* lang-specs.h: Pass -B and -save-temps to regular compile lines.
+	* lang.opt: Add C and Driver options that Modula-2 intercepts for
+	internal use. Reorder options into two sections and to collate.
+
+2023-01-26  Gaius Mulley  <gaiusmod2@gmail.com>
+
+	* gm2-compiler/M2GCCDeclare.mod: Import IsProcedureNoReturn.
+	(DeclareProcedureToGccWholeProgram): New variable declared and set
+	returnType.  Pass returnType to BuildEndFunctionDeclaration.
+	Extra parameter IsProcedureNoReturn passed to
+	BuildEndFunctionDeclaration.
+	* gm2-compiler/M2Quads.mod (BuildM2MainFunction): Correct
+	scaffold comment and add extra return 0.
+	* gm2-compiler/P2Build.bnf: Import BuildNoReturnAttribute.
+	(ProcedureHeading): Process EndBuildFormalParameters before
+	parsing AttributeNoReturn.
+	(DefProcedureHeading): Process EndBuildFormalParameters before
+	parsing AttributeNoReturn.
+	(AttributeNoReturn): Call BuildNoReturnAttribute.
+	* gm2-compiler/P2SymBuild.def (BuildNoReturnAttribute): New
+	procedure.
+	* gm2-compiler/P2SymBuild.mod (BuildNoReturnAttribute): New
+	procedure.
+	* gm2-compiler/SymbolTable.def (PutProcedureInline): Corrected
+	comment.
+	(PutProcedureNoReturn): New procedure.
+	(IsProcedureNoReturn): New procedure function.
+	* gm2-compiler/SymbolTable.mod (SymProcedure): IsNoReturn
+	new field.
+	(MakeProcedure): Initialize IsNoReturn to FALSE.
+	(PutProcedureNoReturn): New procedure.
+	(IsProcedureNoReturn): New procedure function.
+	* gm2-gcc/m2decl.cc (m2decl_BuildEndFunctionDeclaration):
+	Add extra parameter isnoreturn.  Set TREE_THIS_VOLATILE
+	to isnoreturn.
+	* gm2-gcc/m2decl.def (BuildEndFunctionDeclaration): Add
+	extra parameter isnoreturn.
+	* gm2-gcc/m2decl.h (m2decl_BuildEndFunctionDeclaration): Add
+	extra parameter isnoreturn.
+	* gm2-gcc/m2except.cc (m2except_InitExceptions): Change all
+	function decl to pass an extra parameter isnoreturn.
+
+2023-01-26  Gaius Mulley  <gaiusmod2@gmail.com>
+
+	* m2.flex (splitSlashStar): Fix comment so that /* does not
+	appear inside the comment.
+
+2023-01-26  Iain Sandoe  <iain@sandoe.co.uk>
+
+	PR modula2/108553
+	* gm2-lang.cc (gm2_langhook_init_options): Remove debug code.
+
+2023-01-26  Gaius Mulley  <gaiusmod2@gmail.com>
+
+	* Make-lang.in (m2/gm2config.h): Rewrite rule to be
+	dependent upon m2/gm2config.aci.
+	(m2/gm2config.aci): Newrule.
+	* configure.ac (AC_CONFIG_HEADERS): Change destination
+	to gm2config.aci.
+	* configure: Regenerate.
+	* gm2-libs/config-host: Regenerate.
+	* gm2-compiler/M2GCCDeclare.mod (AddSymToWatch): Comment
+	out.
+	* gm2-compiler/M2Quads.mod (BuildConstHighFromSym): Remove
+	Dim.
+	(StartBuildWith): Call BuildStmtNoteTok.
+	(BuildStmtNoteTok): New procedure.
+	(BuildStmtNote): Re-implement re-factor into two
+	procedures and call BuildStmtNoteTok.
+	* gm2config.h.in: Remove.
+	* gm2config.aci.in: New file.
+
+2023-01-25  Iain Sandoe  <iain@sandoe.co.uk>
+
+	PR modula2/102343
+	PR modula2/108182
+	* gm2-compiler/M2Comp.mod: Early exit for pre-processor-only jobs.
+	* gm2-compiler/M2Options.def (SetPPOnly, GetPPOnly, SetMD, GetMD,
+	SetMMD, GetMMD, SetMQ, GetMQ, SetObj, GetObj, SetDumpDir,
+	GetDumpDir):New.
+	* gm2-compiler/M2Options.mod:(SetPPOnly, GetPPOnly, SetMD, GetMD,
+	SetMMD, GetMMD, SetMQ, GetMQ, SetObj, GetObj, SetDumpDir,
+	GetDumpDir):New.
+	* gm2-compiler/M2Preprocess.def (PreprocessModule): Add flag to
+	indicate the main file.
+	* gm2-compiler/M2Preprocess.mod: Handle Preprocess-only jobs,
+	handle MD, MMD and MQ options.
+	* gm2-gcc/m2options.h (M2Options_SetPPOnly, M2Options_GetPPOnly,
+	M2Options_SetDumpDir, M2Options_SetMD, M2Options_GetMD,
+	M2Options_SetMMD, M2Options_GetMMD, M2Options_SetMQ, M2Options_GetMQ,
+	M2Options_SetObj, M2Options_GetObj): New.
+	* gm2-gcc/m2type.cc (m2type_InitBaseTypes): Early exit for pre-
+	processor-only jobs.
+	* gm2-lang.cc (gm2_langhook_init): Handle preprocess-only commands.
+	(gm2_langhook_option_lang_mask): Claim C and Driver options so that
+	we can intercept them for building pre-processor commands.
+	(gm2_langhook_init_options): Collect the preprocessor line here.
+	Save options that have different actions for preprocessor and compile
+	commands.
+	(gm2_langhook_handle_option): Only handle the modula-2 options here.
+	(gm2_langhook_post_options): Do not create a back-end for pre-
+	processor-only jobs.
+	* gm2spec.cc (lang_specific_driver): Ignore PCH options, append a
+	scaffold-main for cases where we are building a main module with
+	-c.
+	* lang-specs.h: Revise to handle preprocessor-only jobs and to
+	consume pre-processed files.
+	* lang.opt: Remove Driver and C options copies (we claim these
+	separately).
+
+2023-01-24  Co-Authored by: Iain Sandoe  <iain@sandoe.co.uk>
+
+	* Make-lang.in (GM2-COMP-BOOT-DEFS): Add
+	DynamicStringPath.def.
+	(GM2-COMP-BOOT-MODS): Add DynamicStringPath.mod.
+	(GM2-COMP-DEFS): Add DynamicStringPath.def.
+	(GM2-COMP-MODS): Add DynamicStringPath.mod.
+	($(objdir)/m2/gm2-libs-min/SYSTEM.def): Split path into
+	multiple -I components.
+	($(objdir)/m2/gm2-libs/SYSTEM.def): Ditto.
+	($(objdir)/m2/gm2-libs-coroutines/SYSTEM.def): Ditto.
+	* gm2-compiler/M2Options.mod: Import DynamicStringPath.
+	(SetSearchPath): Reimplement using DynamicStringPath
+	procedures.
+	* gm2-compiler/M2Search.def (InitSearchPath): Remove.
+	(PrependSearchPath): Remove.
+	* gm2-compiler/M2Search.mod (SFIO): Remove import.
+	(DynamicStringPath): Add import.
+	(Directory): Remove.
+	(UserPath): Remove.
+	(InitialPath): Remove.
+	(InitSearchPath): Remove.
+	(PrependSearchPath): Remove.
+	(FindSourceFile): Re-implement.
+	(FindSourceDefFile): Re-implement.
+	(FindSourceModFile): Re-implement.
+	* gm2-gcc/init.cc (_M2_DynamicStringPath_init):
+	New prototype.
+	(init_FrontEndInit): Call _M2_DynamicStringPath_init.
+	* tools-src/makeSystem: Allow multiple -I paths.
+	* gm2-compiler/DynamicStringPath.def: New file.
+	* gm2-compiler/DynamicStringPath.mod: New file.
+	* gm2-gcc/m2options.h (M2Options_SetMakeIncludePath): Add
+	prototype.
+
+2023-01-24  Gaius Mulley  <gaiusmod2@gmail.com>
+
+	* m2.flex (cpreprocessor): Add temporary variable
+	which is initialized to 0.
+	(commentCLevel): New variable.
+	(endOfCComment): New function.
+	(splitSlashStar): New function to split /* into / and *
+	tokens.
+	(COMMENTC): New flex state.
+	("/*"): New rule to test whether we should treat /*
+	as a single token or as two tokens.
+	(<COMMENTC>.): New rule to skip a character.
+	(<COMMENTC>\n.*): New rule to consume the line.
+	(<COMMENTC>"*/"): New rule to call endOfCComment.
+
+2023-01-24  Gaius Mulley  <gaiusmod2@gmail.com>
+
+	* gm2-libs-iso/RTco.def: Import RTentity.
+	Declare RTco as a definition for C module.
+
+2023-01-23  Iain Sandoe  <iain@sandoe.co.uk>
+
+	PR modula2/108182
+	PR modula2/108480
+	* Make-lang.in: Pass libsubdir to the language init
+	build.
+	* gm2-lang.cc (INCLUDE_VECTOR): Define.
+	(add_one_import_path): New.
+	(add_m2_import_paths): New.
+	(gm2_langhook_post_options): Arrange to add the include
+	paths (and add the system ones) in the same order as C
+	uses.
+	* gm2spec.cc (build_archive_path): Remove.
+	(add_default_combination): Remove.
+	(add_default_archives): Remove.
+	(add_default_libs): We no longer need a '-L' option, just
+	emit the -l and each library in use.
+	(build_include_path): Remove.
+	(add_include): Remove.
+	(add_default_includes): Remove.
+	(library_installed): Remove.
+	(check_valid_library): Remove.
+	(check_valid_list): Remove.
+	(convert_abbreviation): Diagnose unhandled cases.
+	(lang_specific_driver): Skip options where we will add back
+	a validated version.
+	* lang-specs.h (M2CPP): Reformat, append %I when -fcpp is not
+	in use.  Revise the cc1gm2 spec to omit mentioning options that
+	are handled in the c pre-processor line.
+	* lang.opt: Allow preprocessing and path options as input to the
+	cc1gm2 invocation, so that they can be passed to the preprocessor
+	invocation.
+
+2023-01-23  Iain Sandoe  <iain@sandoe.co.uk>
+
+	PR modula2/108405
+	* gm2-libs-iso/Preemptive.mod (initPreemptive): Use a value for
+	extra space that is divisible by common OS pagesizes.
+
+2023-01-20  Gaius Mulley  <gaiusmod2@gmail.com>
+
+	* gm2-libs/Args.mod (GetArg): Check index before
+	accessing array.
+	* gm2-libs/M2Dependent.mod (toCString): Check index
+	before accessing array.
+	* mc-boot/GArgs.c: Rebuilt.
+	* mc-boot/GM2Dependent.c: Rebuilt.
+	* mc-boot/Gkeyc.c: Rebuilt.
+	* mc/keyc.mod (seenUIntMin): Initialize once.
+	(seenUIntMax): Initialize once.
+	(checkLimits): Only test seenUIntMin and seenUIntMax
+	once.
+	* pge-boot/GArgs.c:  Rebuilt.
+	* pge-boot/GM2Dependent.c: Rebuilt.
+
+2023-01-20  Gaius Mulley  <gaiusmod2@gmail.com>
+
+	* gm2-gcc/m2statement.cc (gm2_gimplify_function_node):
+	Remove.
+	* gm2-libs/DynamicStrings.mod (Equal): Remove dead code.
+	* m2.flex (<COMMENT>"<*"): Add {} for else statement.
+	* m2pp.cc (hextree): Add conditional #ifdef DEBUGGING.
+	* mc-boot/GDynamicStrings.c: Rebuild.
+	* pge-boot/GDynamicStrings.c: Rebuild.
+	* pge-boot/GFIO.c: Rebuild.
+	* pge-boot/GIndexing.c: Rebuild.
+	* pge-boot/GM2EXCEPTION.c: Rebuild.
+	* pge-boot/GM2RTS.c: Rebuild.
+	* pge-boot/GNameKey.c: Rebuild.
+	* pge-boot/GPushBackInput.c: Rebuild.
+	* pge-boot/GRTExceptions.c: Rebuild.
+	* pge-boot/GStdIO.c: Rebuild.
+	* pge-boot/GSymbolKey.c: Rebuild.
+	* pge-boot/GSysStorage.c: Rebuild.
+
+2023-01-17  Gaius Mulley  <gaiusmod2@gmail.com>
+
+	* mc-boot/GM2RTS.c: Rebuilt.
+	* mc-boot/GM2RTS.h: Rebuilt.
+	* mc-boot/Gdecl.c: Rebuilt.
+	* mc-boot/GmcOptions.c: Rebuilt.
+	* mc/mcOptions.mod (displayVersion):
+	Split first printf into three components
+
+2023-01-17  Gaius Mulley  <gaiusmod2@gmail.com>
+
+	* gm2-libs-iso/M2RTS.def (Halt): Parameter file renamed to filename.
+	(HaltC): New procedure declaration.
+	(ErrorMessage): Parameter file renamed to filename.
+	* gm2-libs-iso/M2RTS.mod (Halt): Parameter file renamed to
+	filename.
+	(HaltC): New procedure implementation.
+	(ErrorStringC): New procedure implementation.
+	(ErrorMessageC): New procedure implementation.
+	* gm2-libs/M2RTS.def (Halt): Parameter file renamed to filename.
+	(HaltC): New procedure declaration.
+	(ErrorMessage): Parameter file renamed to filename.
+	* gm2-libs/M2RTS.mod (Halt): Parameter file renamed to filename.
+	(HaltC): New procedure implementation.
+	(ErrorStringC): New procedure implementation.
+	(ErrorMessageC): New procedure implementation.
+
+2023-01-16  Gaius Mulley  <gaiusmod2@gmail.com>
+
+	* mc-boot-ch/Glibc.c (libc_time): New function.
+	(libc_localtime): New function.
+	* mc-boot/GDynamicStrings.c: Regenerate.
+	* mc-boot/GFIO.c: Regenerate.
+	* mc-boot/GFormatStrings.c: Regenerate.
+	* mc-boot/GIndexing.c: Regenerate.
+	* mc-boot/GM2Dependent.c: Regenerate.
+	* mc-boot/GM2EXCEPTION.c: Regenerate.
+	* mc-boot/GPushBackInput.c: Regenerate.
+	* mc-boot/GRTExceptions.c: Regenerate.
+	* mc-boot/GRTint.c: Regenerate.
+	* mc-boot/GStdIO.c: Regenerate.
+	* mc-boot/GStringConvert.c: Regenerate.
+	* mc-boot/GSysStorage.c: Regenerate.
+	* mc-boot/Gdecl.c: Regenerate.
+	* mc-boot/GmcComment.c: Regenerate.
+	* mc-boot/GmcComp.c: Regenerate.
+	* mc-boot/GmcDebug.c: Regenerate.
+	* mc-boot/GmcMetaError.c: Regenerate.
+	* mc-boot/GmcOptions.c: Regenerate.
+	* mc-boot/GmcStack.c: Regenerate.
+	* mc-boot/GnameKey.c: Regenerate.
+	* mc-boot/GsymbolKey.c: Regenerate.
+	* mc-boot/Gkeyc.c: Regenerate.
+	* mc/decl.mod (putFieldRecord): Change NulName to NulKey
+	and fix type comparision.
+	* mc/mcOptions.mod (YEAR): Remove.
+	(getYear): New procedure function.
+	(displayVersion): Use result from getYear instead of YEAR.
+	Emit boilerplate for GPL v3.
+	(gplBody): Use result from getYear instead of YEAR.
+	(glplBody): Use result from getYear instead of YEAR.
+
+2023-01-16  Gaius Mulley  <gaiusmod2@gmail.com>
+
+	* gm2-compiler/M2Quads.mod (AssignUnboundedVar): Check Type
+	against NulSym and call MetaErrorT1 if necessary.
+	(AssignUnboundedNonVar): Check Type against NulSym and
+	call MetaErrorT1 if necessary.
+	(BuildDesignatorPointer): Check Type1 against NulSym and
+	call MetaErrorT1 if necessary.
+
+2023-01-16  Gaius Mulley  <gaiusmod2@gmail.com>
+
+	* mc/mcOptions.mod (displayVersion): Change GPLv2 to GPLv3.
+	(YEAR) set to 2023.
+
 2023-01-15  Gaius Mulley  <gaiusmod2@gmail.com>
 
 	* gm2-compiler/M2LexBuf.mod (isSrcToken): Add block comment.
diff --git a/gcc/m2/Make-lang.in b/gcc/m2/Make-lang.in
index 367be8e..03677d9 100644
--- a/gcc/m2/Make-lang.in
+++ b/gcc/m2/Make-lang.in
@@ -176,7 +176,7 @@ m2/gm2-libs.texi: gm2-libs.texi-check; @true
 ifeq ($(HAVE_PYTHON),yes)
 gm2-libs.texi-check: m2/SYSTEM-pim.texi m2/SYSTEM-iso.texi m2/Builtins.texi \
                      $(objdir)/m2/gm2-libs-coroutines/SYSTEM.def
-	test -d m2/gm2-libs-pim || $(mkinstalldirs) m2/gm2-libs-pim
+	test -d m2/gm2-libs-log || $(mkinstalldirs) m2/gm2-libs-log
 	test -d m2/gm2-libs-iso || $(mkinstalldirs) m2/gm2-libs-iso
 	test -d m2/gm2-libs || $(mkinstalldirs) m2/gm2-libs
 	$(PYTHON) $(srcdir)/m2/tools-src/def2doc.py -t -uLibraries -s$(srcdir)/m2 -b$(objdir)/m2 -o $(objdir)/m2/gm2-libs.texi
@@ -543,6 +543,7 @@ m2/gm2-gcc/m2configure.o: $(srcdir)/m2/gm2-gcc/m2configure.cc \
 
 m2/gm2-lang.o: $(srcdir)/m2/gm2-lang.cc gt-m2-gm2-lang.h $(GCC_HEADER_DEPENDENCIES_FOR_M2)
 	$(COMPILER) -c -g $(GM2GCC) $(ALL_COMPILERFLAGS) \
+	    -DLIBSUBDIR=\"$(libsubdir)\" \
             $(ALL_CPPFLAGS) $(INCLUDES) $< $(OUTPUT_OPTION)
 
 m2/stor-layout.o: $(srcdir)/stor-layout.cc $(GCC_HEADER_DEPENDENCIES_FOR_M2)
@@ -689,6 +690,7 @@ GM2-COMP-BOOT-DEFS = \
    M2DebugStack.def \
    M2Defaults.def \
    M2DriverOptions.def \
+   DynamicStringPath.def \
    M2Emit.def \
    M2Error.def \
    M2EvalSym.def \
@@ -760,6 +762,7 @@ GM2-COMP-BOOT-MODS = \
    M2DebugStack.mod \
    M2Defaults.mod \
    M2DriverOptions.mod \
+   DynamicStringPath.mod \
    M2Emit.mod \
    M2Error.mod \
    M2FileName.mod \
@@ -964,6 +967,7 @@ GM2-COMP-DEFS = \
    M2DebugStack.def \
    M2Defaults.def \
    M2DriverOptions.def \
+   DynamicStringPath.def \
    M2Emit.def \
    M2Error.def \
    M2FileName.def \
@@ -1031,6 +1035,7 @@ GM2-COMP-MODS = \
    M2DebugStack.mod \
    M2Defaults.mod \
    M2DriverOptions.mod \
+   DynamicStringPath.mod \
    M2Emit.mod \
    M2Error.mod \
    M2FileName.mod \
@@ -1498,7 +1503,10 @@ m2/gm2-libs/gm2-libs-host.h:
 # Autoconf inserts -DCROSS_DIRECTORY_STRUCTURE if we are building a
 # cross compiler and the ../Makefile.in above appends this to INTERNAL_CFLAGS.
 
-m2/gm2config.h:
+m2/gm2config.h: m2/gm2config.aci
+	grep -v define\ PACKAGE_ $< > $@
+
+m2/gm2config.aci:
 	NEW_SRCDIR=`${srcdir}/m2/tools-src/calcpath ../ ${srcdir} m2` ; \
         export NEW_SRCDIR ; \
 	cd m2 ; \
@@ -1521,7 +1529,7 @@ $(objdir)/m2/gm2-libs-min/SYSTEM.def: $(GM2_PROG_DEP)
 	$(SHELL) $(srcdir)/m2/tools-src/makeSystem -fpim \
              $(srcdir)/m2/gm2-libs-min/SYSTEM.def \
              $(srcdir)/m2/gm2-libs-min/SYSTEM.mod \
-             -I$(srcdir)/m2/gm2-libs-min:$(srcdir)/m2/gm2-libs \
+             -I$(srcdir)/m2/gm2-libs-min -I$(srcdir)/m2/gm2-libs \
              "$(GM2_FOR_TARGET)" $@
 
 $(objdir)/m2/gm2-libs/SYSTEM.def: $(GM2_PROG_DEP)
@@ -1539,7 +1547,7 @@ $(objdir)/m2/gm2-libs-iso/SYSTEM.def: $(GM2_PROG_DEP)
 	$(SHELL) $(srcdir)/m2/tools-src/makeSystem -fiso \
              $(srcdir)/m2/gm2-libs-iso/SYSTEM.def \
              $(srcdir)/m2/gm2-libs-iso/SYSTEM.mod \
-             -I$(srcdir)/m2/gm2-libs-iso:$(srcdir)/m2/gm2-libs \
+             -I$(srcdir)/m2/gm2-libs-iso -I$(srcdir)/m2/gm2-libs \
              "$(GM2_FOR_TARGET)" $@
 
 $(objdir)/m2/gm2-libs-coroutines/SYSTEM.def: $(GM2_PROG_DEP)
@@ -1547,7 +1555,7 @@ $(objdir)/m2/gm2-libs-coroutines/SYSTEM.def: $(GM2_PROG_DEP)
 	$(SHELL) $(srcdir)/m2/tools-src/makeSystem -fpim \
              $(srcdir)/m2/gm2-libs-coroutines/SYSTEM.def \
              $(srcdir)/m2/gm2-libs-coroutines/SYSTEM.mod \
-             -I$(srcdir)/m2/gm2-libs-coroutines:$(srcdir)/m2/gm2-libs-iso:$(srcdir)/m2/gm2-libs \
+             -I$(srcdir)/m2/gm2-libs-coroutines -I$(srcdir)/m2/gm2-libs-iso -I$(srcdir)/m2/gm2-libs \
              "$(GM2_FOR_TARGET)" $@
 
 build-compiler: $(GM2-COMP-MODS:%.mod=m2/gm2-compiler/%.o) \
diff --git a/gcc/m2/configure b/gcc/m2/configure
index 91768ab..de78fdd 100755
--- a/gcc/m2/configure
+++ b/gcc/m2/configure
@@ -3645,7 +3645,7 @@ $as_echo "#define HAVE_OPENDIR 1" >>confdefs.h
 
 fi
 
-ac_config_headers="$ac_config_headers gm2config.h"
+ac_config_headers="$ac_config_headers gm2config.aci"
 
 cat >confcache <<\_ACEOF
 # This file is a shell script that caches the results of configure
@@ -4319,7 +4319,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
 for ac_config_target in $ac_config_targets
 do
   case $ac_config_target in
-    "gm2config.h") CONFIG_HEADERS="$CONFIG_HEADERS gm2config.h" ;;
+    "gm2config.aci") CONFIG_HEADERS="$CONFIG_HEADERS gm2config.aci" ;;
 
   *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
   esac
@@ -4630,7 +4630,7 @@ $as_echo "$as_me: $ac_file is unchanged" >&6;}
 
 
   case $ac_file$ac_mode in
-    "gm2config.h":H) echo timestamp > stamp-h ;;
+    "gm2config.aci":H) echo timestamp > stamp-h ;;
 
   esac
 done # for ac_tag
diff --git a/gcc/m2/configure.ac b/gcc/m2/configure.ac
index a9c952a..0a77cae 100644
--- a/gcc/m2/configure.ac
+++ b/gcc/m2/configure.ac
@@ -1,4 +1,4 @@
-# configure.ac provides gm2spec.c with access to config values.
+# configure.ac provides gm2spec.cc with access to config values.
 
 # Copyright (C) 2001-2023 Free Software Foundation, Inc.
 # Contributed by Gaius Mulley <gaius.mulley@southwales.ac.uk>.
@@ -29,5 +29,5 @@ AC_CHECK_FUNCS([stpcpy])
 AC_CHECK_HEADERS(sys/types.h)
 AC_HEADER_DIRENT
 AC_CHECK_LIB([c],[opendir],[AC_DEFINE([HAVE_OPENDIR],[1],[found opendir])])
-AC_CONFIG_HEADERS(gm2config.h, [echo timestamp > stamp-h])
+AC_CONFIG_HEADERS(gm2config.aci, [echo timestamp > stamp-h])
 AC_OUTPUT
diff --git a/gcc/m2/gm2-compiler/DynamicStringPath.def b/gcc/m2/gm2-compiler/DynamicStringPath.def
new file mode 100644
index 0000000..e9fdff7
--- /dev/null
+++ b/gcc/m2/gm2-compiler/DynamicStringPath.def
@@ -0,0 +1,113 @@
+(* DynamicStringPath.def implements a path for DynamicStrings.
+
+Copyright (C) 2001-2023 Free Software Foundation, Inc.
+Contributed by Gaius Mulley <gaius.mulley@southwales.ac.uk>.
+
+This file is part of GNU Modula-2.
+
+GNU Modula-2 is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 3, or (at your option)
+any later version.
+
+GNU Modula-2 is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+<http://www.gnu.org/licenses/>.  *)
+
+DEFINITION MODULE DynamicStringPath ;  (*!m2iso+gm2*)
+
+FROM DynamicStrings IMPORT String ;
+
+TYPE
+   PathList ;
+
+
+(*
+   GetUserPath - returns the current UserPath.
+*)
+
+PROCEDURE GetUserPath () : PathList ;
+
+
+(*
+   GetSystemPath - returns the current SystemPath.
+*)
+
+PROCEDURE GetSystemPath () : PathList ;
+
+
+(*
+   SetUserPath - assigns UserPath to pl.
+*)
+
+PROCEDURE SetUserPath (pl: PathList) ;
+
+
+(*
+   SetSystemPath - assigns SystemPath to pl.
+*)
+
+PROCEDURE SetSystemPath (pl: PathList) ;
+
+
+(*
+   InitPathList - creates a new empty path list.
+*)
+
+PROCEDURE InitPathList (str: String) : PathList ;
+
+
+(*
+   KillPathList - places list pl onto the freelist.
+                  Postcondition: pl will be NIL.
+*)
+
+PROCEDURE KillPathList (VAR pl: PathList) ;
+
+
+(*
+   Cons - appends str to the end of a path list.
+          If pl is NIL a new list is created and returned
+          containing str.
+*)
+
+PROCEDURE Cons (pl: PathList; str: String) : PathList ;
+
+
+(*
+   ConsList - concatenates path list left and right together.
+              It always returns NIL which should be assigned
+              to the callers right parameter after ConsList
+              has been completed signifying that right should
+              no longer be accessed.
+*)
+
+PROCEDURE ConsList (left, right: PathList) : PathList ;
+
+
+(*
+   Stash - returns pl before setting pl to NIL.
+*)
+
+PROCEDURE Stash (VAR pl: PathList) : PathList ;
+
+
+(*
+   FindFileName - returns NIL if a file cannot be found otherwise
+                  it returns the path including the filename.
+*)
+
+PROCEDURE FindFileName (filename: String; pl: PathList) : String ;
+
+
+END DynamicStringPath.
diff --git a/gcc/m2/gm2-compiler/DynamicStringPath.mod b/gcc/m2/gm2-compiler/DynamicStringPath.mod
new file mode 100644
index 0000000..601456e
--- /dev/null
+++ b/gcc/m2/gm2-compiler/DynamicStringPath.mod
@@ -0,0 +1,265 @@
+(* DynamicStringPath.def implements a path for DynamicStrings.
+
+Copyright (C) 2001-2023 Free Software Foundation, Inc.
+Contributed by Gaius Mulley <gaius.mulley@southwales.ac.uk>.
+
+This file is part of GNU Modula-2.
+
+GNU Modula-2 is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 3, or (at your option)
+any later version.
+
+GNU Modula-2 is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+<http://www.gnu.org/licenses/>.  *)
+
+IMPLEMENTATION MODULE DynamicStringPath ;  (*!m2iso+gm2*)
+
+FROM Storage IMPORT ALLOCATE, DEALLOCATE ;
+FROM DynamicStrings IMPORT InitString, ConCat, ConCatChar, char, Dup,
+                           KillString, Length ;
+FROM SFIO IMPORT Exists ;
+FROM FIO IMPORT StdErr ;
+FROM M2Printf IMPORT fprintf0, fprintf1 ;
+
+CONST
+   Directory = '/' ;
+   Debugging = FALSE ;
+
+TYPE
+   PathList = POINTER TO RECORD
+                            tail,
+                            next : PathList ;
+                            entry: String ;
+                         END ;
+
+
+VAR
+   FreeList,
+   DefaultUserPath,
+   DefaultSystemPath: PathList ;
+
+
+(*
+   GetUserPath - returns the current UserPath.
+*)
+
+PROCEDURE GetUserPath () : PathList ;
+BEGIN
+   RETURN DefaultUserPath
+END GetUserPath ;
+
+
+(*
+   GetSystemPath - returns the current SystemPath.
+*)
+
+PROCEDURE GetSystemPath () : PathList ;
+BEGIN
+   RETURN DefaultSystemPath
+END GetSystemPath ;
+
+
+(*
+   SetUserPath - assigns UserPath to pl.
+*)
+
+PROCEDURE SetUserPath (pl: PathList) ;
+BEGIN
+   DefaultUserPath := pl ;
+   DumpPath ('DefaultUserPath', DefaultUserPath)
+END SetUserPath ;
+
+
+(*
+   SetSystemPath - assigns SystemPath to pl.
+*)
+
+PROCEDURE SetSystemPath (pl: PathList) ;
+BEGIN
+   DefaultSystemPath := pl ;
+   DumpPath ('DefaultSystemPath', DefaultSystemPath)
+END SetSystemPath ;
+
+
+(*
+   KillPathList - places list pl onto the freelist.
+                  Postcondition: pl will be NIL.
+*)
+
+PROCEDURE KillPathList (VAR pl: PathList) ;
+BEGIN
+   IF pl # NIL
+   THEN
+      pl^.tail^.next := FreeList ;
+      FreeList := pl ;
+      pl := NIL
+   END
+END KillPathList ;
+
+
+(*
+   InitPathList - creates a new empty path list.
+                  It takes a copy of the string.
+*)
+
+PROCEDURE InitPathList (str: String) : PathList ;
+VAR
+   pl: PathList ;
+BEGIN
+   NEW (pl) ;
+   WITH pl^ DO
+      tail := pl ;
+      next := NIL ;
+      entry := Dup (str)
+   END ;
+   RETURN pl
+END InitPathList ;
+
+
+(*
+   Cons - appends str to the end of a path list.
+          If pl is NIL a new list is created and returned
+          containing str.
+*)
+
+PROCEDURE Cons (pl: PathList; str: String) : PathList ;
+BEGIN
+   IF pl = NIL
+   THEN
+      pl := InitPathList (str)
+   ELSE
+      pl := ConsList (pl, InitPathList (str))
+   END ;
+   RETURN pl
+END Cons ;
+
+
+(*
+   ConsList - concatenates path list left and right together.
+              It always returns NIL which should be assigned
+              to the callers right parameter after ConsList
+              has been completed signifying that right should
+              no longer be accessed.
+*)
+
+PROCEDURE ConsList (left, right: PathList) : PathList ;
+BEGIN
+   IF right # NIL
+   THEN
+      left^.tail^.next := right ;
+      left^.tail := right^.tail
+   END ;
+   RETURN left
+END ConsList ;
+
+
+(*
+   Stash - returns pl before setting pl to NIL.
+*)
+
+PROCEDURE Stash (VAR pl: PathList) : PathList ;
+VAR
+   old: PathList ;
+BEGIN
+   old := pl ;
+   pl := NIL ;
+   RETURN old
+END Stash ;
+
+
+(*
+   AddDir - if str is not empty and does not end with / then add
+            a directory.
+            Postcondition: str is returned (with a '/' at the end)
+            or is empty.
+*)
+
+PROCEDURE AddDir (str: String) : String ;
+BEGIN
+   IF Length (str) > 0
+   THEN
+      IF char (str, -1) # Directory
+      THEN
+         str := ConCatChar (str, Directory)
+      END
+   END ;
+   RETURN str
+END AddDir ;
+
+
+(*
+   FindFileName - returns NIL if a file cannot be found otherwise
+                  it returns the path including the filename.
+*)
+
+PROCEDURE FindFileName (filename: String; pl: PathList) : String ;
+VAR
+   s: String ;
+BEGIN
+   WHILE pl # NIL DO
+      s := ConCat (AddDir (Dup (pl^.entry)), Dup (filename)) ;
+      IF Debugging
+      THEN
+         fprintf1 (StdErr, "testing for %s: ", s)
+      END ;
+      IF Exists (s)
+      THEN
+         IF Debugging
+         THEN
+            fprintf0 (StdErr, "yes\n")
+         END ;
+         RETURN s
+      END ;
+      IF Debugging
+      THEN
+         fprintf0 (StdErr, "no\n")
+      END ;
+      s := KillString (s) ;
+      pl := pl^.next
+   END ;
+   IF Debugging
+   THEN
+      fprintf1 (StdErr, "FindFileName did not find: %s in path\n", filename)
+   END ;
+   RETURN NIL
+END FindFileName ;
+
+
+(*
+   DumpPath - debugging dump of the pathlist.
+*)
+
+PROCEDURE DumpPath (name: ARRAY OF CHAR; pl: PathList) ;
+BEGIN
+   IF Debugging
+   THEN
+      fprintf0 (StdErr, name) ;
+      fprintf0 (StdErr, ":") ;
+      WHILE pl # NIL DO
+         fprintf0 (StdErr, " {") ;
+         fprintf1 (StdErr, "%s", pl^.entry) ;
+         fprintf0 (StdErr, "}") ;
+         pl := pl^.next
+      END ;
+      fprintf0 (StdErr, "\n")
+   END
+END DumpPath ;
+
+
+BEGIN
+   DefaultSystemPath := NIL ;
+   DefaultUserPath := NIL ;
+   FreeList := NIL
+END DynamicStringPath.
diff --git a/gcc/m2/gm2-compiler/M2Comp.mod b/gcc/m2/gm2-compiler/M2Comp.mod
index fd5ea1b..3c2c364 100644
--- a/gcc/m2/gm2-compiler/M2Comp.mod
+++ b/gcc/m2/gm2-compiler/M2Comp.mod
@@ -22,7 +22,8 @@ along with GNU Modula-2; see the file COPYING3.  If not see
 IMPLEMENTATION MODULE M2Comp ;
 
 
-FROM M2Options IMPORT Statistics, Quiet, WholeProgram, ExtendedOpaque, GenModuleList ;
+FROM M2Options IMPORT PPonly, Statistics, Quiet, WholeProgram,
+                      ExtendedOpaque, GenModuleList ;
 
 FROM M2Pass IMPORT SetPassToPass0, SetPassToPass1, SetPassToPass2, SetPassToPassC, SetPassToPass3,
                    SetPassToNoPass, SetPassToPassHidden ;
@@ -38,7 +39,7 @@ FROM libc IMPORT exit ;
 FROM M2Error IMPORT ErrorStringAt, ErrorStringAt2, ErrorStringsAt2,
                     WriteFormat0, FlushErrors, FlushWarnings, ResetErrorScope ;
 
-FROM M2MetaError IMPORT MetaErrorString1, MetaError0, MetaError1 ;
+FROM M2MetaError IMPORT MetaErrorString0, MetaErrorString1, MetaError0, MetaError1, MetaString0 ;
 FROM FormatStrings IMPORT Sprintf1 ;
 FROM P0SymBuild IMPORT P0Init, P1Init ;
 
@@ -60,11 +61,12 @@ FROM SymbolTable IMPORT GetSymName, IsDefImp, NulSym,
                         ResolveConstructorTypes, SanityCheckConstants, IsDefinitionForC,
                         IsBuiltinInModule, PutModLink, IsDefLink, IsModLink ;
 
-FROM FIO IMPORT StdErr ;
+FROM FIO IMPORT StdErr, StdOut ;
 FROM NameKey IMPORT Name, GetKey, KeyToCharStar, makekey ;
 FROM M2Printf IMPORT fprintf1 ;
 FROM M2Quiet IMPORT qprintf0, qprintf1, qprintf2 ;
 FROM DynamicStrings IMPORT String, InitString, KillString, InitStringCharStar, Dup, Mark, string ;
+FROM M2Options IMPORT Verbose ;
 
 CONST
    Debugging = FALSE ;
@@ -126,6 +128,10 @@ PROCEDURE Compile (s: String) ;
 BEGIN
    DoPass0(s) ;
    FlushWarnings ; FlushErrors ;
+   IF PPonly
+   THEN
+      RETURN
+   END;
    ResetForNewPass ; ResetErrorScope ;
    qprintf0('Pass 1: scopes, enumerated types, imports and exports\n') ;
    DoPass1 ;
@@ -167,6 +173,8 @@ END compile ;
 *)
 
 PROCEDURE ExamineCompilationUnit (VAR name: ADDRESS; VAR isdefimp: BOOLEAN) ;
+VAR
+   Message: String ;
 BEGIN
    isdefimp := FALSE ;   (* default to program module *)
    (* stop if we see eof, ';' or '[' *)
@@ -183,8 +191,9 @@ BEGIN
       END ;
       GetToken
    END ;
-   m2flex.M2Error(string(InitString('failed to find module name'))) ;
-   exit(1)
+   Message := MetaString0 (InitString ('no {%kMODULE} name found')) ;
+   m2flex.M2Error (string (Message)) ;
+   exit (1)
 END ExamineCompilationUnit ;
 
 
@@ -198,20 +207,20 @@ VAR
    name    : ADDRESS ;
    isdefimp: BOOLEAN ;
 BEGIN
-   IF OpenSource(PreprocessModule(s))
+   IF OpenSource (s)
    THEN
-      ExamineCompilationUnit(name, isdefimp) ;
+      ExamineCompilationUnit (name, isdefimp) ;
       IF isdefimp
       THEN
-         SetMainModule(MakeImplementationSource(GetTokenNo(), makekey(name)))
+         SetMainModule (MakeImplementationSource (GetTokenNo (), makekey (name)))
       ELSE
-         SetMainModule(MakeProgramSource(GetTokenNo(), makekey(name)))
+         SetMainModule (MakeProgramSource (GetTokenNo (), makekey (name)))
       END ;
       CloseSource ;
       ReInitialize
    ELSE
-      fprintf1(StdErr, 'failed to open %s\n', s) ;
-      exit(1)
+      fprintf1 (StdErr, 'failed to open %s\n', s) ;
+      exit (1)
    END
 END PeepInto ;
 
@@ -226,15 +235,26 @@ VAR
    Sym     : CARDINAL ;
    i       : CARDINAL ;
    SymName,
-   FileName: String ;
+   FileName,
+   PPSource: String ;
 BEGIN
    P0Init ;
    SetPassToPass0 ;
-   PeepInto(s) ;
+   (* Maybe preprocess the main file.  *)
+   PPSource := PreprocessModule(s, TRUE);
+   IF PPonly
+   THEN
+      RETURN
+   END;
+   PeepInto (PPSource) ;
    Main := GetMainModule() ;
    i := 1 ;
    Sym := GetModuleNo(i) ;
-   qprintf1('Compiling: %s\n', s) ;
+   qprintf1('Compiling: %s\n', PPSource) ;
+   IF Verbose
+   THEN
+      fprintf1(StdOut, 'Compiling: %s\n', PPSource) ;
+   END ;
    qprintf0('Pass 0: lexical analysis, parsing, modules and associated filenames\n') ;
    WHILE Sym#NulSym DO
       SymName := InitStringCharStar(KeyToCharStar(GetSymName(Sym))) ;
@@ -243,7 +263,7 @@ BEGIN
          IF FindSourceDefFile(SymName, FileName)
          THEN
             ModuleType := Definition ;
-            IF OpenSource(AssociateDefinition(PreprocessModule(FileName), Sym))
+            IF OpenSource(AssociateDefinition(PreprocessModule(FileName, FALSE), Sym))
             THEN
                IF NOT P0SyntaxCheck.CompilationUnit()
                THEN
@@ -280,15 +300,16 @@ BEGIN
          (* only need to read implementation module if hidden types are declared or it is the main module *)
          IF Main=Sym
          THEN
-            FileName := Dup(s)
+            FileName := Dup (PPSource)
          ELSE
             IF FindSourceModFile (SymName, FileName)
             THEN
+               FileName := PreprocessModule (FileName, FALSE)
             END
          END ;
          IF FileName#NIL
          THEN
-            IF OpenSource (AssociateModule (PreprocessModule (FileName), Sym))
+            IF OpenSource (AssociateModule (Dup (FileName), Sym))
             THEN
                IF NOT P0SyntaxCheck.CompilationUnit()
                THEN
@@ -325,7 +346,7 @@ BEGIN
             IF FindSourceModFile (SymName, FileName)
             THEN
                qprintf2 ('   Module %-20s : %s (linking)\n', SymName, FileName) ;
-               IF OpenSource (AssociateModule (PreprocessModule (FileName), Sym))
+               IF OpenSource (AssociateModule (PreprocessModule (FileName, FALSE), Sym))
                THEN
                   PutModLink (Sym, TRUE) ;   (* This source is only used to determine link time info.  *)
                   IF NOT P0SyntaxCheck.CompilationUnit ()
diff --git a/gcc/m2/gm2-compiler/M2GCCDeclare.mod b/gcc/m2/gm2-compiler/M2GCCDeclare.mod
index fa27cb4..445c039 100644
--- a/gcc/m2/gm2-compiler/M2GCCDeclare.mod
+++ b/gcc/m2/gm2-compiler/M2GCCDeclare.mod
@@ -105,7 +105,7 @@ FROM SymbolTable IMPORT NulSym,
                         IsAModula2Type, UsesVarArgs,
                         GetSymName, GetParent,
                         GetDeclaredMod, GetVarBackEndType,
-                        GetProcedureBeginEnd,
+                        GetProcedureBeginEnd, IsProcedureNoReturn,
                         GetString, GetStringLength, IsConstString,
                         IsConstStringM2, IsConstStringC, IsConstStringM2nul, IsConstStringCnul,
                         GetAlignment, IsDeclaredPacked, PutDeclaredPacked,
@@ -347,6 +347,7 @@ END DebugSetNumbers ;
                    lists.
 *)
 
+(*
 PROCEDURE AddSymToWatch (sym: WORD) ;
 BEGIN
    IF (sym#NulSym) AND (NOT IsElementInSet(WatchList, sym))
@@ -357,6 +358,7 @@ BEGIN
       FIO.FlushBuffer(FIO.StdOut)
    END
 END AddSymToWatch ;
+*)
 
 
 (*
@@ -2345,6 +2347,7 @@ END IsExternalToWholeProgram ;
 
 PROCEDURE DeclareProcedureToGccWholeProgram (Sym: CARDINAL) ;
 VAR
+   returnType,
    GccParam  : Tree ;
    scope,
    Son,
@@ -2389,20 +2392,17 @@ BEGIN
       PushBinding(scope) ;
       IF GetSType(Sym)=NulSym
       THEN
-         PreAddModGcc(Sym, BuildEndFunctionDeclaration(begin, end,
-                                                       KeyToCharStar(GetFullSymName(Sym)),
-                                                       NIL,
-                                                       IsExternalToWholeProgram(Sym),
-                                                       IsProcedureGccNested(Sym),
-                                                       IsExported(GetModuleWhereDeclared(Sym), Sym)))
+         returnType := NIL
       ELSE
-         PreAddModGcc(Sym, BuildEndFunctionDeclaration(begin, end,
-                                                       KeyToCharStar(GetFullSymName(Sym)),
-                                                       Mod2Gcc(GetSType(Sym)),
-                                                       IsExternalToWholeProgram(Sym),
-                                                       IsProcedureGccNested(Sym),
-                                                       IsExported(GetModuleWhereDeclared(Sym), Sym)))
+         returnType := Mod2Gcc(GetSType(Sym))
       END ;
+      PreAddModGcc(Sym, BuildEndFunctionDeclaration(begin, end,
+                                                    KeyToCharStar(GetFullSymName(Sym)),
+                                                    returnType,
+                                                    IsExternalToWholeProgram(Sym),
+                                                    IsProcedureGccNested(Sym),
+                                                    IsExported(GetModuleWhereDeclared(Sym), Sym),
+                                                    IsProcedureNoReturn(Sym))) ;
       PopBinding(scope) ;
       WatchRemoveList(Sym, todolist) ;
       WatchIncludeList(Sym, fullydeclared)
@@ -2479,7 +2479,8 @@ BEGIN
                                                       IsExternal (Sym),  (* Extern relative to the main module.  *)
                                                       IsProcedureGccNested (Sym),
                                                       (* Exported from the module where it was declared.  *)
-                                                      IsExported (GetModuleWhereDeclared (Sym), Sym) OR IsExtern (Sym))) ;
+                                                      IsExported (GetModuleWhereDeclared (Sym), Sym) OR IsExtern (Sym),
+                                                      IsProcedureNoReturn(Sym))) ;
       PopBinding(scope) ;
       WatchRemoveList(Sym, todolist) ;
       WatchIncludeList(Sym, fullydeclared)
diff --git a/gcc/m2/gm2-compiler/M2LexBuf.mod b/gcc/m2/gm2-compiler/M2LexBuf.mod
index a557f4e..ac496f2 100644
--- a/gcc/m2/gm2-compiler/M2LexBuf.mod
+++ b/gcc/m2/gm2-compiler/M2LexBuf.mod
@@ -82,6 +82,8 @@ VAR
    ListOfTokens     : ListDesc ;
    CurrentTokNo     : CARDINAL ;
    InsertionIndex   : CARDINAL ;
+   SeenEof          : BOOLEAN ;  (* Have we seen eof since the last call
+                                    to OpenSource.  *)
 
 
 (*
@@ -122,6 +124,7 @@ END InitTokenList ;
 
 PROCEDURE Init ;
 BEGIN
+   SeenEof := FALSE ;
    InsertionIndex := 0 ;
    currenttoken := eoftok ;
    CurrentTokNo := InitialSourceToken ;
@@ -337,6 +340,7 @@ END SetFile ;
 
 PROCEDURE OpenSource (s: String) : BOOLEAN ;
 BEGIN
+   SeenEof := FALSE ;
    IF UseBufferedTokens
    THEN
       GetToken ;
@@ -606,6 +610,27 @@ END DumpTokens ;
 
 
 (*
+   GetNonEofToken - providing that we have not already seen an eof for this source
+                    file call m2flex.GetToken and GetToken if requested.
+*)
+
+PROCEDURE GetNonEofToken (callGetToken: BOOLEAN) ;
+BEGIN
+   IF SeenEof
+   THEN
+      currenttoken := eoftok
+   ELSE
+      (* Call the lexical phase to place a new token into the last bucket.  *)
+      m2flex.GetToken () ;
+      IF callGetToken
+      THEN
+         GetToken
+      END
+   END
+END GetNonEofToken ;
+
+
+(*
    GetToken - gets the next token into currenttoken.
 *)
 
@@ -622,7 +647,7 @@ BEGIN
    ELSE
       IF ListOfTokens.tail=NIL
       THEN
-         m2flex.GetToken () ;
+         GetNonEofToken (FALSE) ;
          IF ListOfTokens.tail=NIL
          THEN
             HALT
@@ -630,16 +655,14 @@ BEGIN
       END ;
       IF CurrentTokNo>=ListOfTokens.LastBucketOffset
       THEN
-         (* CurrentTokNo is in the last bucket or needs to be read *)
+         (* CurrentTokNo is in the last bucket or needs to be read.  *)
          IF CurrentTokNo-ListOfTokens.LastBucketOffset<ListOfTokens.tail^.len
          THEN
             UpdateFromBucket (ListOfTokens.tail,
                               CurrentTokNo-ListOfTokens.LastBucketOffset)
          ELSE
-            (* call the lexical phase to place a new token into the last bucket *)
-            m2flex.GetToken () ;
-            GetToken ;  (* and call ourselves again to collect the token from bucket *)
-            RETURN
+            (* and call ourselves again to collect the token from bucket *)
+            GetNonEofToken (TRUE)
          END
       ELSE
          t := CurrentTokNo ;
@@ -1175,6 +1198,10 @@ PROCEDURE AddTok (t: toktype) ;
 VAR
    s: String ;
 BEGIN
+   IF t = eoftok
+   THEN
+      SeenEof := TRUE
+   END ;
    IF NOT ((t=eoftok) AND IsLastTokenEof())
    THEN
       AddTokToList(t, NulName, 0,
diff --git a/gcc/m2/gm2-compiler/M2Options.def b/gcc/m2/gm2-compiler/M2Options.def
index e7b34cf..dd26984 100644
--- a/gcc/m2/gm2-compiler/M2Options.def
+++ b/gcc/m2/gm2-compiler/M2Options.def
@@ -52,11 +52,12 @@ EXPORT QUALIFIED SetReturnCheck, SetNilCheck, SetCaseCheck,
 		 SetWholeValueCheck, GetWholeValueCheck,
                  SetLowerCaseKeywords,
                  SetIndex, SetRange, SetWholeDiv, SetStrictTypeChecking,
-                 Setc, Getc, SetUselist, GetUselist, GetUselistFilename,
-                 SetShared, SetB,
+                 Setc, Getc, SetPPOnly, GetPPOnly,
+                 SetUselist, GetUselist, GetUselistFilename,
+                 SetShared,
 
                  Iso, Pim, Pim2, Pim3, Pim4,
-                 cflag,
+                 PPonly, cflag,
                  PositiveModFloorDiv,
                  Pedantic, Verbose, Statistics,
                  UnboundedByReference, VerboseUnbounded,
@@ -83,7 +84,7 @@ EXPORT QUALIFIED SetReturnCheck, SetNilCheck, SetCaseCheck,
                  DebugBuiltins, setdefextension, setmodextension,
                  SetStatistics, SetWall,
                  SetSaveTemps, SetSaveTempsDir, SaveTemps, GetSaveTempsDir,
-                 GenModuleList,
+                 SetDumpDir, GetDumpDir, GenModuleList,
                  CppArg, CppCommandLine, CppRemember,
 		 SetDebugFunctionLineNumbers, DebugFunctionLineNumbers,
 		 SetGenerateStatementNote, GenerateStatementNote,
@@ -92,10 +93,12 @@ EXPORT QUALIFIED SetReturnCheck, SetNilCheck, SetCaseCheck,
                  SetScaffoldMain, ScaffoldMain,
                  SetRuntimeModuleOverride, GetRuntimeModuleOverride,
                  SetGenModuleList, GetGenModuleFilename, SharedFlag,
-                 GetB ;
+                 SetB, GetB, SetMD, GetMD, SetMMD, GetMMD, SetObj, GetObj,
+                 GetMQ, SetMQ ;
 
 
 VAR
+   PPonly,                       (* -E/M/MM present? - preprocessing only    *)
    cflag,                        (* -c flag present?                         *)
    Iso,                          (* -fiso use ISO SYSTEM.def                 *)
    Pim,                          (* -fpim use PIM [234] SYSTEM.def           *)
@@ -174,6 +177,18 @@ VAR
    Coding,
    Profiling               : BOOLEAN ;
 
+(*
+   SetPPOnly - set the PPonly to value (on E, M, MM).
+*)
+
+PROCEDURE SetPPOnly (value: BOOLEAN) ;
+
+
+(*
+   GetPPOnly - get the PPonly (Preprocess only).
+*)
+
+PROCEDURE GetPPOnly () : BOOLEAN ;
 
 (*
    Setc - set the cflag (compile only flag -c) to value.
@@ -195,13 +210,64 @@ PROCEDURE Getc () : BOOLEAN ;
 
 PROCEDURE SetB (arg: ADDRESS) ;
 
-
 (*
    GetB - returns argument to the -B option as a string or NIL if it were never set.
 *)
 
 PROCEDURE GetB () : ADDRESS ;
 
+(*
+   SetMD - assigns MD file to arg.
+*)
+
+PROCEDURE SetMD (arg: ADDRESS) ;
+
+(*
+   GetMD - returns the filename set for MD or NIL if it was never set.
+*)
+
+PROCEDURE GetMD () : ADDRESS ;
+
+
+(*
+   SetMMD - assigns MMD file to arg.
+*)
+
+PROCEDURE SetMMD (arg: ADDRESS) ;
+
+(*
+   GetMMD - returns the filename set for MMD or NIL if it was never set.
+*)
+
+PROCEDURE GetMMD () : ADDRESS ;
+
+(*
+   SetMQ - assigns MQ file to arg.
+*)
+
+PROCEDURE SetMQ (arg: ADDRESS) ;
+
+(*
+   GetMQ - returns the filename set for MQ or NIL if it was never set.
+*)
+
+PROCEDURE GetMQ () : ADDRESS ;
+
+(*
+   SetScaffoldDynamic - set the -fscaffold-dynamic flag.
+*)
+
+(*
+   SetObj - assigns given object file to arg.
+*)
+
+PROCEDURE SetObj (arg: ADDRESS) ;
+
+(*
+   GetObj - returns the filename set for Object or NIL if it was never set.
+*)
+
+PROCEDURE GetObj () : ADDRESS ;
 
 (*
    SetScaffoldDynamic - set the -fscaffold-dynamic flag.
@@ -784,6 +850,19 @@ PROCEDURE SetSaveTempsDir (arg: ADDRESS) ;
 
 PROCEDURE GetSaveTempsDir () : String ;
 
+(*
+   SetDumpDir - Specify dump dir.
+*)
+
+PROCEDURE SetDumpDir (arg: ADDRESS) ;
+
+
+(*
+   GetDumpDir - return DumpDir or NIL.
+*)
+
+PROCEDURE GetDumpDir () : String ;
+
 
 (*
    SetGenModuleList - set the GenModuleList flag to value and pass
diff --git a/gcc/m2/gm2-compiler/M2Options.mod b/gcc/m2/gm2-compiler/M2Options.mod
index f046e29..865b857 100644
--- a/gcc/m2/gm2-compiler/M2Options.mod
+++ b/gcc/m2/gm2-compiler/M2Options.mod
@@ -24,8 +24,10 @@ IMPLEMENTATION MODULE M2Options ;
 
 IMPORT CmdArgs ;
 FROM SArgs IMPORT GetArg, Narg ;
-FROM M2Search IMPORT PrependSearchPath, SetDefExtension, SetModExtension ;
-FROM M2Printf IMPORT printf0, printf1 ;
+FROM M2Search IMPORT SetDefExtension, SetModExtension ;
+FROM DynamicStringPath IMPORT Cons, GetUserPath, SetUserPath, Cons ;
+FROM M2Printf IMPORT printf0, printf1, fprintf1 ;
+FROM FIO IMPORT StdErr ;
 FROM libc IMPORT exit ;
 FROM Debug IMPORT Halt ;
 FROM m2linemap IMPORT location_t ;
@@ -52,7 +54,12 @@ CONST
 
 VAR
    Barg,
+   MDarg,
+   MMDarg,
+   MQarg,
+   CmdLineObj,
    SaveTempsDir,
+   DumpDir,
    GenModuleListFilename,
    UselistFilename,
    RuntimeModuleOverride,
@@ -131,6 +138,94 @@ END GetB ;
 
 
 (*
+   SetMD - assigns MDarg to the filename from arg.
+   This overrides any previous MMD.
+*)
+
+PROCEDURE SetMD (arg: ADDRESS) ;
+BEGIN
+   MMDarg := KillString (MMDarg) ;
+   MDarg := KillString (MDarg) ;
+   MDarg := InitStringCharStar (arg)
+END SetMD ;
+
+
+(*
+   GetMD - returns MDarg filename as a c-string or NIL if it was never set.
+*)
+
+PROCEDURE GetMD () : ADDRESS ;
+BEGIN
+   RETURN string (MDarg)
+END GetMD ;
+
+
+(*
+   SetMMD - assigns MMDarg to the filename from arg.
+   This overrides any previous MD.
+*)
+
+PROCEDURE SetMMD (arg: ADDRESS) ;
+BEGIN
+   MDarg := KillString (MDarg) ;
+   MMDarg := KillString (MMDarg) ;
+   MMDarg := InitStringCharStar (arg)
+END SetMMD ;
+
+
+(*
+   GetMMD - returns MMDarg filename as a c-string or NIL if it was never set.
+*)
+
+PROCEDURE GetMMD () : ADDRESS ;
+BEGIN
+   RETURN string (MMDarg)
+END GetMMD ;
+
+
+(*
+   SetMQ - assigns MQarg to the filename from arg.
+*)
+
+PROCEDURE SetMQ (arg: ADDRESS) ;
+BEGIN
+   MQarg := KillString (MQarg) ;
+   MQarg := InitStringCharStar (arg)
+END SetMQ ;
+
+
+(*
+   GetMMD - returns MQarg filename as a c-string or NIL if it was never set.
+*)
+
+PROCEDURE GetMQ () : ADDRESS ;
+BEGIN
+   RETURN string (MQarg)
+END GetMQ ;
+
+
+(*
+   SetObj - assigns CmdLineObj to the filename from arg.
+*)
+
+PROCEDURE SetObj (arg: ADDRESS) ;
+BEGIN
+   CmdLineObj := KillString (CmdLineObj) ;
+   CmdLineObj := InitStringCharStar (arg)
+END SetObj ;
+
+
+(*
+   GetObj - returns CmdLineObj filename as a c-string or NIL if it was never set.
+*)
+
+PROCEDURE GetObj () : ADDRESS ;
+BEGIN
+   RETURN string (CmdLineObj)
+END GetObj ;
+
+
+(*
    CppCommandLine - returns the Cpp command line and all arguments.
                     NIL is returned if the -fcpp is absent.
 *)
@@ -363,6 +458,25 @@ END GetCpp ;
 
 
 (*
+   SetPPOnly - set the PPonly (preprocess only) to value.
+*)
+
+PROCEDURE SetPPOnly (value: BOOLEAN) ;
+BEGIN
+   PPonly := value
+END SetPPOnly ;
+
+(*
+   GetPPOnly - get the PPonly (preprocess only).
+*)
+
+PROCEDURE GetPPOnly () : BOOLEAN ;
+BEGIN
+   RETURN PPonly
+END GetPPOnly ;
+
+
+(*
    Setc - set the cflag (compile only flag -c) to value.
 *)
 
@@ -789,10 +903,10 @@ BEGIN
    s := InitStringCharStar(arg) ;
    IF Debugging
    THEN
-      printf1("setting search path to: %s\n", s)
+      fprintf1 (StdErr, "M2Search.SetSearchPath setting search path to: %s\n", s)
    END ;
-   PrependSearchPath(s) ;
-   s := KillString(s)
+   SetUserPath (Cons (GetUserPath (), s)) ;
+   s := KillString (s)
 END SetSearchPath ;
 
 
@@ -1048,7 +1162,8 @@ END SetSaveTemps ;
 
 PROCEDURE SetSaveTempsDir (arg: ADDRESS) ;
 BEGIN
-   SaveTempsDir := InitStringCharStar (arg)
+   SaveTempsDir := InitStringCharStar (arg) ;
+   SaveTemps := TRUE
 END SetSaveTempsDir ;
 
 
@@ -1061,6 +1176,24 @@ BEGIN
    RETURN SaveTempsDir
 END GetSaveTempsDir ;
 
+(*
+   SetDumpDir - Set the dump dir.
+*)
+
+PROCEDURE SetDumpDir (arg: ADDRESS) ;
+BEGIN
+   DumpDir := InitStringCharStar (arg)
+END SetDumpDir ;
+
+
+(*
+   GetDumpDir - return DumpDir or NIL.
+*)
+
+PROCEDURE GetDumpDir () : String ;
+BEGIN
+   RETURN DumpDir
+END GetDumpDir ;
 
 (*
    SetScaffoldDynamic - set the -fscaffold-dynamic flag.
@@ -1245,5 +1378,9 @@ BEGIN
    GenModuleListFilename        := NIL ;
    SharedFlag                   := FALSE ;
    Barg                         := NIL ;
-   SaveTempsDir                 := NIL
+   MDarg                        := NIL ;
+   MMDarg                       := NIL ;
+   MQarg                        := NIL ;
+   SaveTempsDir                 := NIL ;
+   DumpDir                      := NIL
 END M2Options.
diff --git a/gcc/m2/gm2-compiler/M2Preprocess.def b/gcc/m2/gm2-compiler/M2Preprocess.def
index 08fe192..0258580 100644
--- a/gcc/m2/gm2-compiler/M2Preprocess.def
+++ b/gcc/m2/gm2-compiler/M2Preprocess.def
@@ -45,7 +45,7 @@ EXPORT QUALIFIED PreprocessModule ;
                       All temporary files will be deleted when the compiler exits.
 *)
 
-PROCEDURE PreprocessModule (filename: String) : String ;
+PROCEDURE PreprocessModule (filename: String; isMain: BOOLEAN) : String ;
 
 
 END M2Preprocess.
diff --git a/gcc/m2/gm2-compiler/M2Preprocess.mod b/gcc/m2/gm2-compiler/M2Preprocess.mod
index eb08015..d63db35 100644
--- a/gcc/m2/gm2-compiler/M2Preprocess.mod
+++ b/gcc/m2/gm2-compiler/M2Preprocess.mod
@@ -25,7 +25,7 @@ IMPLEMENTATION MODULE M2Preprocess ;
 FROM SYSTEM IMPORT WORD ;
 
 FROM DynamicStrings IMPORT string, InitString, Mark, KillString, EqualArray, InitStringCharStar,
-                           Dup, ConCat, ConCatChar, RIndex, Slice ;
+                           Dup, ConCat, ConCatChar, RIndex, Slice, Length ;
 
 FROM choosetemp IMPORT make_temp_file ;
 FROM pexecute IMPORT pexecute ;
@@ -33,7 +33,8 @@ FROM libc IMPORT system, exit, unlink, printf, atexit ;
 FROM Lists IMPORT List, InitList, KillList, IncludeItemIntoList, ForeachItemInListDo ;
 FROM FIO IMPORT StdErr, StdOut ;
 FROM M2Printf IMPORT fprintf1 ;
-FROM M2Options IMPORT Verbose, CppCommandLine, SaveTemps ;
+FROM M2Options IMPORT Verbose, PPonly, GetObj, GetMD, GetMMD, GetMQ,
+                      CppCommandLine, SaveTemps, GetSaveTempsDir, GetDumpDir ;
 FROM NameKey IMPORT Name, MakeKey, KeyToCharStar, makekey ;
 
 
@@ -77,14 +78,80 @@ BEGIN
    RETURN 0
 END RemoveFiles ;
 
+(*
+   Return the filename with no path.
+*)
+
+PROCEDURE GetFileName (Path: String) : String ;
+VAR
+   fstart: INTEGER ;
+BEGIN
+   fstart := RIndex(Path, '/', 0) ;
+   IF fstart=-1
+   THEN
+      fstart := 0
+   ELSE
+      fstart := fstart + 1
+   END ;
+   RETURN Dup (Slice(Path, fstart, Length (Path)))
+END GetFileName ;
+
+
+(*
+   Return basename.
+*)
+
+PROCEDURE BaseName (Path: String) : String ;
+VAR
+   ext,
+   basename: INTEGER ;
+BEGIN
+   basename := RIndex(Path, '/', 0) ;
+   IF basename=-1
+   THEN
+      basename := 0
+   ELSE
+      basename := basename + 1
+   END ;
+   ext := RIndex(Path, '.', 0) ;
+   IF ext=-1
+   THEN
+      ext := 0
+   END ;
+   RETURN Dup (Slice(Path, basename, ext))
+END BaseName ;
 
 (*
-   MakeSaveTempsFileName - return a temporary file "filename.i".
+   MakeSaveTempsFileName - return a temporary file like 
+   "./filename.{def,mod}.m2i" in the CWD unless SaveTempsDir = obj,
+   when we put it in the dumpdir if that is specified (or fallback to '.'
+   if not).
+   We have to keep the original extension because that disambiguates .def
+   and .mod files (otherwise, we'd need two 'preprocessed' extensions).
 *)
 
 PROCEDURE MakeSaveTempsFileName (filename: String) : String ;
+VAR
+   NewName,
+   DumpDir,
+   NewDir : String ;
 BEGIN
-   RETURN ConCat (Dup (filename), InitString ('.i'))
+   NewName := ConCat (GetFileName (filename), InitString ('.m2i')) ;
+   NewDir := GetSaveTempsDir () ;
+   DumpDir := GetDumpDir () ;
+(*   IF Verbose
+   THEN
+      fprintf1 (StdOut, "newname: %s", NewName) ;
+      fprintf1 (StdOut, " NewDir: %s", NewDir) ;
+      fprintf1 (StdOut, " DumpDir: %s\n", DumpDir)
+   END ;
+*)
+   IF (NewDir#NIL) AND EqualArray (NewDir, 'obj') AND (DumpDir#NIL)
+   THEN
+      RETURN Dup (ConCat (DumpDir, NewName))
+   ELSE
+      RETURN Dup (ConCat (InitString ('./'), NewName))
+   END ;
 END MakeSaveTempsFileName ;
 
 
@@ -98,7 +165,7 @@ END MakeSaveTempsFileName ;
                       All temporary files will be deleted when the compiler exits.
 *)
 
-PROCEDURE PreprocessModule (filename: String) : String ;
+PROCEDURE PreprocessModule (filename: String; isMain: BOOLEAN) : String ;
 VAR
    tempfile,
    command,
@@ -107,18 +174,55 @@ BEGIN
    command := CppCommandLine () ;
    IF (command = NIL) OR EqualArray (command, '')
    THEN
-      RETURN filename
+      RETURN Dup (filename)
    ELSE
-      IF SaveTemps
+      commandLine := Dup (command) ;
+      tempfile := NIL ;
+      (* We support MD and MMD for the main file only, at present.  *)
+      IF isMain OR PPonly
+      THEN
+         IF GetMD () # NIL
+         THEN
+            tempfile := ConCat( Mark (InitString(' -MD ')),
+                                InitStringCharStar (GetMD ()))
+         ELSIF GetMMD () # NIL
+         THEN
+            tempfile := ConCat( Mark (InitString(' -MMD ')),
+                                InitStringCharStar (GetMMD ()))
+         END ;
+         IF tempfile#NIL
+         THEN
+            commandLine := ConCat (Dup (commandLine), Dup (tempfile)) ;
+            (* We can only add MQ if we already have an MD/MMD.  *)
+            IF GetMQ () # NIL
+            THEN
+               tempfile := ConCat( Mark (InitString(' -MQ ')),
+                                 InitStringCharStar (GetMQ ())) ;
+               commandLine := ConCat (Dup (commandLine), Dup (tempfile))
+            END ;
+         END ;
+      END ;
+      (* The output file depends on whether we are in stand-alone PP mode, and
+         if an output file is specified.  *)
+      tempfile := NIL ;
+      IF PPonly
+      THEN
+         IF GetObj () # NIL
+         THEN
+           tempfile := InitStringCharStar (GetObj ())
+         END ;
+      ELSIF SaveTemps
       THEN
-         tempfile := InitStringCharStar (MakeSaveTempsFileName (filename))
+         tempfile := MakeSaveTempsFileName (filename)
       ELSE
-         tempfile := InitStringCharStar (make_temp_file (KeyToCharStar (MakeKey('i'))))
+         tempfile := InitStringCharStar (make_temp_file (KeyToCharStar (MakeKey('.m2i'))))
+      END ;
+      commandLine := ConCat (ConCatChar (Dup (commandLine), ' '), filename) ;
+      IF tempfile # NIL
+      THEN
+         commandLine := ConCat (ConCat (Dup (commandLine),
+                                        Mark (InitString(' -o '))), tempfile) ;
       END ;
-      commandLine := Dup (command) ;
-      commandLine := ConCat (ConCat (ConCat (ConCatChar (Dup (commandLine), ' '), filename),
-                                     Mark (InitString(' -o '))),
-                             tempfile) ;
 (*  use pexecute in the future
       res := pexecute(string(Slice(commandLine, 0, Index(commandLine, ' ', 0))), etc etc );
 *)
diff --git a/gcc/m2/gm2-compiler/M2Quads.mod b/gcc/m2/gm2-compiler/M2Quads.mod
index 263fb7c..3b6ed45 100644
--- a/gcc/m2/gm2-compiler/M2Quads.mod
+++ b/gcc/m2/gm2-compiler/M2Quads.mod
@@ -2469,6 +2469,7 @@ BEGIN
             }
             catch (...) {
                RTExceptions_DefaultErrorCatch ();
+               return 0;
             }
          }
       *)
@@ -2492,10 +2493,11 @@ BEGIN
       PushTtok (RequestSym (tokno, MakeKey ("envp")), tokno) ;
       PushT (3) ;
       BuildProcedureCall (tokno) ;
-
       PushZero (tokno, Integer) ;
       BuildReturn (tokno) ;
       BuildExcept (tokno) ;
+      PushZero (tokno, Integer) ;
+      BuildReturn (tokno) ;
       EndScope ;
       BuildProcedureEnd ;
       PopN (1)
@@ -6327,7 +6329,10 @@ BEGIN
    ELSIF IsVar(Sym)
    THEN
       Type := GetDType(Sym) ;
-      IF IsUnbounded(Type)
+      IF Type = NulSym
+      THEN
+         MetaErrorT1 (tok, '{%1ad} has no type and cannot be passed to a VAR formal parameter', Sym)
+      ELSIF IsUnbounded(Type)
       THEN
          IF Type = GetSType (UnboundedSym)
          THEN
@@ -6382,7 +6387,10 @@ BEGIN
    ELSIF IsVar (Sym)
    THEN
       Type := GetDType (Sym) ;
-      IF IsUnbounded (Type)
+      IF Type = NulSym
+      THEN
+         MetaErrorT1 (tok, '{%1ad} has no type and cannot be passed to a non VAR formal parameter', Sym)
+      ELSIF IsUnbounded (Type)
       THEN
          UnboundedNonVarLinkToArray (tok, Sym, ArraySym, UnboundedSym, ParamType, dim)
       ELSIF IsArray (Type) OR IsGenericSystemType (ParamType)
@@ -8095,14 +8103,11 @@ END BuildHighFunction ;
 
 PROCEDURE BuildConstHighFromSym (tok: CARDINAL) ;
 VAR
-   Dim,
    NoOfParam,
    ReturnVar: CARDINAL ;
 BEGIN
    PopT (NoOfParam) ;
    ReturnVar := MakeTemporary (tok, ImmediateValue) ;
-   Dim := OperandD (1) ;
-   INC (Dim) ;
    GenHigh (tok, ReturnVar, 1, OperandT (1)) ;
    PopN (NoOfParam+1) ;
    PushTtok (ReturnVar, tok)
@@ -11386,7 +11391,10 @@ VAR
 BEGIN
    PopTFrwtok (Sym1, Type1, rw, exprtok) ;
    Type1 := SkipType (Type1) ;
-   IF IsUnknown (Sym1)
+   IF Type1 = NulSym
+   THEN
+      MetaErrorT1 (ptrtok, '{%1ad} has no type and therefore cannot be dereferenced by ^', Sym1)
+   ELSIF IsUnknown (Sym1)
    THEN
       MetaError1 ('{%1EMad} is undefined and therefore {%1ad}^ cannot be resolved', Sym1)
    ELSIF IsPointer (Type1)
@@ -11436,6 +11444,7 @@ VAR
    Sym, Type,
    Ref      : CARDINAL ;
 BEGIN
+   BuildStmtNoteTok (withTok) ;
    DisplayStack ;
    PopTFtok (Sym, Type, tok) ;
    Type := SkipType (Type) ;
@@ -14098,26 +14107,37 @@ END PushLineNo ;
 
 PROCEDURE BuildStmtNote (offset: INTEGER) ;
 VAR
-   filename: Name ;
-   f       : QuadFrame ;
-   i       : INTEGER ;
+   tokenno: INTEGER ;
 BEGIN
    IF NextQuad#Head
    THEN
-      f := GetQF (NextQuad-1) ;
-      i := offset ;
-      INC (i, GetTokenNo ()) ;
-      (* no need to have multiple notes at the same position.  *)
-      IF (f^.Operator # StatementNoteOp) OR (f^.Operand3 # VAL (CARDINAL, i))
-      THEN
-         filename := makekey (string (GetFileName ())) ;
-         GenQuad (StatementNoteOp, WORD (filename), NulSym, i)
-      END
+      tokenno := offset ;
+      INC (tokenno, GetTokenNo ()) ;
+      BuildStmtNoteTok (VAL(CARDINAL, tokenno))
    END
 END BuildStmtNote ;
 
 
 (*
+   BuildStmtNoteTok - adds a nop (with an assigned tokenno location) to the code.
+*)
+
+PROCEDURE BuildStmtNoteTok (tokenno: CARDINAL) ;
+VAR
+   filename: Name ;
+   f       : QuadFrame ;
+BEGIN
+   f := GetQF (NextQuad-1) ;
+   (* no need to have multiple notes at the same position.  *)
+   IF (f^.Operator # StatementNoteOp) OR (f^.Operand3 # tokenno)
+   THEN
+      filename := makekey (string (GetFileName ())) ;
+      GenQuad (StatementNoteOp, WORD (filename), NulSym, tokenno)
+   END
+END BuildStmtNoteTok ;
+
+
+(*
    AddRecordToList - adds the record held on the top of stack to the
                      list of records and varient fields.
 *)
diff --git a/gcc/m2/gm2-compiler/M2Search.def b/gcc/m2/gm2-compiler/M2Search.def
index 9bed7eb..3d17237 100644
--- a/gcc/m2/gm2-compiler/M2Search.def
+++ b/gcc/m2/gm2-compiler/M2Search.def
@@ -31,31 +31,6 @@ DEFINITION MODULE M2Search ;
 *)
 
 FROM DynamicStrings IMPORT String ;
-EXPORT QUALIFIED InitSearchPath, PrependSearchPath, FindSourceFile,
-                 FindSourceDefFile, FindSourceModFile,
-                 SetDefExtension, SetModExtension ;
-
-
-(*
-   InitSearchPath - assigns the search path to Path.
-                    The string Path may take the form:
-
-                    Path           ::= IndividualPath { ":" IndividualPath }
-                    IndividualPath ::= "." | DirectoryPath
-                    DirectoryPath  ::= [ "/" ] Name { "/" Name }
-                    Name           ::= Letter { (Letter | Number) }
-                    Letter         ::= A..Z | a..z
-                    Number         ::= 0..9
-*)
-
-PROCEDURE InitSearchPath (Path: String) ;
-
-
-(*
-   PrependSearchPath - prepends a new path to the initial search path.
-*)
-
-PROCEDURE PrependSearchPath (path: String) ;
 
 
 (*
diff --git a/gcc/m2/gm2-compiler/M2Search.mod b/gcc/m2/gm2-compiler/M2Search.mod
index e2dd82d..cc61ebf 100644
--- a/gcc/m2/gm2-compiler/M2Search.mod
+++ b/gcc/m2/gm2-compiler/M2Search.mod
@@ -22,9 +22,9 @@ along with GNU Modula-2; see the file COPYING3.  If not see
 IMPLEMENTATION MODULE M2Search ;
 
 
-FROM SFIO IMPORT Exists ;
 FROM M2FileName IMPORT CalculateFileName ;
 FROM Assertion IMPORT Assert ;
+FROM DynamicStringPath IMPORT GetUserPath, GetSystemPath, FindFileName ;
 
 FROM DynamicStrings IMPORT InitString, InitStringChar,
                            KillString, ConCat, ConCatChar, Index, Slice,
@@ -35,13 +35,10 @@ FROM DynamicStrings IMPORT InitString, InitStringChar,
 
 
 CONST
-   Directory        =   '/' ;
    GarbageDebugging = FALSE ;
 
 VAR
-   Def, Mod,
-   UserPath,
-   InitialPath: String ;
+   Def, Mod: String ;
 
 (* Internal garbage collection debugging routines.  *)
 
@@ -110,24 +107,6 @@ END DSdbExit ;
 
 
 (*
-   PrependSearchPath - prepends a new path to the initial search path.
-*)
-
-PROCEDURE PrependSearchPath (path: String) ;
-BEGIN
-   DSdbEnter ;
-   IF EqualArray(UserPath, '')
-   THEN
-      UserPath := KillString(UserPath) ;
-      UserPath := Dup(path)
-   ELSE
-      UserPath := ConCat(ConCatChar(UserPath, ':'), path)
-   END ;
-   DSdbExit (UserPath)
-END PrependSearchPath ;
-
-
-(*
    FindSourceFile - attempts to locate the source file FileName.
                     If a file is found then TRUE is returned otherwise
                     FALSE is returned.
@@ -143,55 +122,13 @@ END PrependSearchPath ;
 
 PROCEDURE FindSourceFile (FileName: String;
                           VAR FullPath: String) : BOOLEAN ;
-VAR
-   CompleteSearchPath: String ;
-   start, end        : INTEGER ;
-   newpath           : String ;
 BEGIN
-   IF EqualArray(UserPath, '')
+   FullPath := FindFileName (FileName, GetUserPath ()) ;
+   IF FullPath = NIL
    THEN
-      IF EqualArray(InitialPath, '')
-      THEN
-         CompleteSearchPath := InitString('.')
-      ELSE
-         CompleteSearchPath := Dup(InitialPath)
-      END
-   ELSE
-      CompleteSearchPath := ConCat(ConCatChar(Dup(UserPath), ':'), InitialPath)
+      FullPath := FindFileName (FileName, GetSystemPath ())
    END ;
-   start := 0 ;
-   end   := Index(CompleteSearchPath, ':', CARDINAL(start)) ;
-   REPEAT
-      IF end=-1
-      THEN
-         end := 0
-      END ;
-      newpath := Slice(CompleteSearchPath, start, end) ;
-      IF EqualArray(newpath, '.')
-      THEN
-         newpath := KillString(newpath) ;
-         newpath := Dup(FileName)
-      ELSE
-         newpath := ConCat(ConCatChar(newpath, Directory), FileName)
-      END ;
-      IF Exists(newpath)
-      THEN
-         FullPath := newpath ;
-         CompleteSearchPath := KillString(CompleteSearchPath) ;
-         RETURN( TRUE )
-      END ;
-      newpath := KillString(newpath) ;
-      IF end#0
-      THEN
-         start := end+1 ;
-         end   := Index(CompleteSearchPath, ':', CARDINAL(start))
-      END
-   UNTIL end=0 ;
-
-   FullPath := NIL ;
-   newpath := KillString(newpath) ;
-   CompleteSearchPath :=  KillString(CompleteSearchPath) ;
-   RETURN( FALSE )
+   RETURN FullPath # NIL
 END FindSourceFile ;
 
 
@@ -206,18 +143,18 @@ PROCEDURE FindSourceDefFile (Stem: String; VAR FullPath: String) : BOOLEAN ;
 VAR
    f: String ;
 BEGIN
-   IF Def#NIL
+   IF Def # NIL
    THEN
-      f := CalculateFileName(Stem, Def) ;
-      IF FindSourceFile(f, FullPath)
+      f := CalculateFileName (Stem, Def) ;
+      IF FindSourceFile (f, FullPath)
       THEN
-         RETURN( TRUE )
+         RETURN TRUE
       END ;
-      f := KillString(f)
+      f := KillString (f)
    END ;
-   (* and try the GNU Modula-2 default extension *)
-   f := CalculateFileName(Stem, Mark(InitString('def'))) ;
-   RETURN( FindSourceFile(f, FullPath) )
+   (* Try the GNU Modula-2 default extension.  *)
+   f := CalculateFileName (Stem, Mark(InitString ('def'))) ;
+   RETURN FindSourceFile (f, FullPath)
 END FindSourceDefFile ;
 
 
@@ -234,16 +171,16 @@ VAR
 BEGIN
    IF Mod#NIL
    THEN
-      f := CalculateFileName(Stem, Mod) ;
-      IF FindSourceFile(f, FullPath)
+      f := CalculateFileName (Stem, Mod) ;
+      IF FindSourceFile (f, FullPath)
       THEN
-         RETURN( TRUE )
+         RETURN TRUE
       END ;
-      f := KillString(f)
+      f := KillString (f)
    END ;
-   (* and try the GNU Modula-2 default extension *)
-   f := CalculateFileName(Stem, Mark(InitString('mod'))) ;
-   RETURN( FindSourceFile(f, FullPath) )
+   (* Try the GNU Modula-2 default extension.  *)
+   f := CalculateFileName (Stem, Mark(InitString ('mod'))) ;
+   RETURN FindSourceFile (f, FullPath)
 END FindSourceModFile ;
 
 
@@ -274,35 +211,11 @@ END SetModExtension ;
 
 
 (*
-   InitSearchPath - assigns the search path to Path.
-                    The string Path may take the form:
-
-                    Path           ::= IndividualPath { ":" IndividualPath }
-                    IndividualPath ::= "." | DirectoryPath
-                    DirectoryPath  ::= [ "/" ] Name { "/" Name }
-                    Name           ::= Letter { (Letter | Number) }
-                    Letter         ::= A..Z | a..z
-                    Number         ::= 0..9
-*)
-
-PROCEDURE InitSearchPath (Path: String) ;
-BEGIN
-   IF InitialPath#NIL
-   THEN
-      InitialPath := KillString(InitialPath)
-   END ;
-   InitialPath := Path
-END InitSearchPath ;
-
-
-(*
-   Init - initializes the search path.
+   Init - initializes the def and mod default string names to NIL.
 *)
 
 PROCEDURE Init ;
 BEGIN
-   UserPath    := InitString('') ;
-   InitialPath := InitStringChar('.') ;
    Def := NIL ;
    Mod := NIL
 END Init ;
diff --git a/gcc/m2/gm2-compiler/P2Build.bnf b/gcc/m2/gm2-compiler/P2Build.bnf
index ee2497b..ea5cfe7 100644
--- a/gcc/m2/gm2-compiler/P2Build.bnf
+++ b/gcc/m2/gm2-compiler/P2Build.bnf
@@ -97,6 +97,7 @@ FROM P2SymBuild IMPORT P2StartBuildProgramModule,
                        StartBuildProcedure,
                        EndBuildProcedure,
                        BuildFunction, BuildOptFunction,
+                       BuildNoReturnAttribute,
 
                        BuildPointerType,
                        BuildRecord, BuildFieldRecord,
@@ -1025,8 +1026,8 @@ ProcedureHeading := "PROCEDURE"                                            % M2E
                                                                            % StartBuildProcedure %
                                                                            % Assert(IsProcedure(OperandT(1))) %
                                                                            % StartBuildFormalParameters  %
-                       [ FormalParameters ] AttributeNoReturn
-                                                                           % EndBuildFormalParameters %
+                       [ FormalParameters ]                                % EndBuildFormalParameters %
+                                            AttributeNoReturn
                                                                            % BuildProcedureHeading %
                      )
                      =:
@@ -1039,8 +1040,8 @@ DefProcedureHeading := "PROCEDURE"                                         % M2E
                                                                            % StartBuildProcedure %
                                                                            % Assert(IsProcedure(OperandT(1))) %
                                                                            % StartBuildFormalParameters  %
-                          [ DefFormalParameters ] AttributeNoReturn
-                                                                           % EndBuildFormalParameters %
+                          [ DefFormalParameters ]                          % EndBuildFormalParameters %
+                                                  AttributeNoReturn
                                                                            % BuildProcedureHeading %
                         )                                                  % M2Error.LeaveErrorScope %
                     =:
@@ -1048,6 +1049,8 @@ DefProcedureHeading := "PROCEDURE"                                         % M2E
 AttributeNoReturn := [ "<*"                                                % PushAutoOn %
                             Ident                                          % PopAuto %
                                                                            % checkReturnAttribute %
+                                                                           % Assert(IsProcedure(OperandT(1))) %
+                                                                           % BuildNoReturnAttribute (OperandT(1)) %
                                    "*>" ] =:
 
 AttributeUnused := [ "<*"                                                  % PushAutoOn %
diff --git a/gcc/m2/gm2-compiler/P2SymBuild.def b/gcc/m2/gm2-compiler/P2SymBuild.def
index d4fc693..d5dd9fe 100644
--- a/gcc/m2/gm2-compiler/P2SymBuild.def
+++ b/gcc/m2/gm2-compiler/P2SymBuild.def
@@ -61,6 +61,7 @@ EXPORT QUALIFIED P2StartBuildDefModule,
                  BuildOptArg,
                  StartBuildProcedure,
                  EndBuildProcedure,
+                 BuildNoReturnAttribute,
                  BuildFunction,
                  BuildOptFunction,
                  BuildPointerType,
@@ -864,6 +865,13 @@ PROCEDURE EndBuildProcedure ;
 
 
 (*
+   BuildNoReturnAttribute - provide an interface to the symbol table module.
+*)
+
+PROCEDURE BuildNoReturnAttribute (procedureSym: CARDINAL) ;
+
+
+(*
    BuildPointerType - builds a pointer type.
                       The Stack:
 
diff --git a/gcc/m2/gm2-compiler/P2SymBuild.mod b/gcc/m2/gm2-compiler/P2SymBuild.mod
index cb80ccf..de56cc4 100644
--- a/gcc/m2/gm2-compiler/P2SymBuild.mod
+++ b/gcc/m2/gm2-compiler/P2SymBuild.mod
@@ -108,6 +108,7 @@ FROM SymbolTable IMPORT NulSym,
                         ParametersDefinedInDefinition,
                         ParametersDefinedInImplementation,
                         ProcedureParametersDefined,
+                        PutProcedureNoReturn,
                         CheckForUnImplementedExports,
                         CheckForUndeclaredExports,
                         IsHiddenTypeDeclared,
@@ -2099,6 +2100,17 @@ END BuildOptFunction ;
 
 
 (*
+   BuildNoReturnAttribute - provide an interface to the symbol table module.
+*)
+
+PROCEDURE BuildNoReturnAttribute (procedureSym: CARDINAL) ;
+BEGIN
+   Assert (IsProcedure (procedureSym)) ;
+   PutProcedureNoReturn (procedureSym, TRUE)
+END BuildNoReturnAttribute ;
+
+
+(*
    BuildPointerType - builds a pointer type.
                       The Stack:
 
diff --git a/gcc/m2/gm2-compiler/SymbolTable.def b/gcc/m2/gm2-compiler/SymbolTable.def
index ffc1a2c..c6c39d9 100644
--- a/gcc/m2/gm2-compiler/SymbolTable.def
+++ b/gcc/m2/gm2-compiler/SymbolTable.def
@@ -191,6 +191,7 @@ EXPORT QUALIFIED NulSym,
                  PutProcedureEndQuad,
                  PutProcedureScopeQuad,
                  PutProcedureReachable,
+                 PutProcedureNoReturn, IsProcedureNoReturn,
                  PutReadQuad, RemoveReadQuad,
                  PutWriteQuad, RemoveWriteQuad,
                  PutGnuAsm, PutGnuAsmOutput, PutGnuAsmInput, PutGnuAsmTrash,
@@ -1274,7 +1275,7 @@ PROCEDURE PutProcedureInline (Sym: CARDINAL) ;
 
 
 (*
-   IsProcedureBuiltin - returns TRUE if this procedure was declared as inlined.
+   IsProcedureInline - returns TRUE if this procedure was declared as inlined.
 *)
 
 PROCEDURE IsProcedureInline (Sym: CARDINAL) : BOOLEAN ;
@@ -1637,6 +1638,21 @@ PROCEDURE IsProcedureReachable (Sym: CARDINAL) : BOOLEAN ;
 
 
 (*
+   PutProcedureNoReturn - places value into the no return attribute
+                          field of procedure sym.
+*)
+
+PROCEDURE PutProcedureNoReturn (Sym: CARDINAL; value: BOOLEAN) ;
+
+
+(*
+   IsProcedureNoReturn - returns TRUE if this procedure never returns.
+*)
+
+PROCEDURE IsProcedureNoReturn (Sym: CARDINAL) : BOOLEAN ;
+
+
+(*
    PutModuleStartQuad - Places QuadNumber into the Module symbol, Sym.
                         QuadNumber is the start quad of Module,
                         Sym.
diff --git a/gcc/m2/gm2-compiler/SymbolTable.mod b/gcc/m2/gm2-compiler/SymbolTable.mod
index 01e431e..cc1a874 100644
--- a/gcc/m2/gm2-compiler/SymbolTable.mod
+++ b/gcc/m2/gm2-compiler/SymbolTable.mod
@@ -360,6 +360,7 @@ TYPE
                IsBuiltin     : BOOLEAN ;    (* Was it declared __BUILTIN__ ? *)
                BuiltinName   : Name ;       (* name of equivalent builtin    *)
                IsInline      : BOOLEAN ;    (* Was it declared __INLINE__ ?  *)
+               IsNoReturn    : BOOLEAN ;    (* Attribute noreturn ?          *)
                ReturnOptional: BOOLEAN ;    (* Is the return value optional? *)
                IsExtern      : BOOLEAN ;    (* Make this procedure extern.   *)
                IsPublic      : BOOLEAN ;    (* Make this procedure visible.  *)
@@ -3775,6 +3776,7 @@ BEGIN
             IsBuiltin := FALSE ;         (* Was it declared __BUILTIN__ ? *)
             BuiltinName := NulName ;     (* name of equivalent builtin    *)
             IsInline := FALSE ;          (* Was is declared __INLINE__ ?  *)
+            IsNoReturn := FALSE ;        (* Declared attribute noreturn ? *)
             ReturnOptional := FALSE ;    (* Is the return value optional? *)
             IsExtern := FALSE ;          (* Make this procedure external. *)
             IsPublic := FALSE ;          (* Make this procedure visible.  *)
@@ -3825,6 +3827,49 @@ END MakeProcedure ;
 
 
 (*
+   PutProcedureNoReturn - places value into the no return attribute
+                          field of procedure sym.
+*)
+
+PROCEDURE PutProcedureNoReturn (Sym: CARDINAL; value: BOOLEAN) ;
+VAR
+   pSym: PtrToSymbol ;
+BEGIN
+   pSym := GetPsym (Sym) ;
+   WITH pSym^ DO
+      CASE SymbolType OF
+
+      ProcedureSym: Procedure.IsNoReturn := value
+
+      ELSE
+         InternalError ('expecting ProcedureSym symbol')
+      END
+   END
+END PutProcedureNoReturn ;
+
+
+(*
+   IsProcedureNoReturn - returns TRUE if this procedure never returns.
+*)
+
+PROCEDURE IsProcedureNoReturn (Sym: CARDINAL) : BOOLEAN ;
+VAR
+   pSym: PtrToSymbol ;
+BEGIN
+   pSym := GetPsym (Sym) ;
+   WITH pSym^ DO
+      CASE SymbolType OF
+
+      ProcedureSym: RETURN Procedure.IsNoReturn
+
+      ELSE
+         InternalError ('expecting ProcedureSym symbol')
+      END
+   END
+END IsProcedureNoReturn ;
+
+
+(*
    PutMonoName - changes the IsMonoName boolean inside the procedure.
 *)
 
diff --git a/gcc/m2/gm2-gcc/init.cc b/gcc/m2/gm2-gcc/init.cc
index 42d8151..a9dfcc7 100644
--- a/gcc/m2/gm2-gcc/init.cc
+++ b/gcc/m2/gm2-gcc/init.cc
@@ -55,6 +55,7 @@ EXTERN void _M2_CmdArgs_init (int argc, char *argv[], char *envp[]);
 EXTERN void _M2_M2Preprocess_init (int argc, char *argv[], char *envp[]);
 EXTERN void _M2_M2Error_init (int argc, char *argv[], char *envp[]);
 EXTERN void _M2_M2Search_init (int argc, char *argv[], char *envp[]);
+EXTERN void _M2_DynamicStringPath_init (int argc, char *argv[], char *envp[]);
 EXTERN void _M2_Indexing_init (int argc, char *argv[], char *envp[]);
 EXTERN void _M2_NameKey_init (int argc, char *argv[], char *envp[]);
 EXTERN void _M2_NumberIO_init (int argc, char *argv[], char *envp[]);
@@ -141,6 +142,7 @@ init_FrontEndInit (void)
   _M2_StrLib_init (0, NULL, NULL);
   _M2_dtoa_init (0, NULL, NULL);
   _M2_ldtoa_init (0, NULL, NULL);
+  _M2_DynamicStringPath_init (0, NULL, NULL);
   _M2_M2Search_init (0, NULL, NULL);
   _M2_M2Options_init (0, NULL, NULL);
 }
diff --git a/gcc/m2/gm2-gcc/m2decl.cc b/gcc/m2/gm2-gcc/m2decl.cc
index fb4d7dc..ab40937 100644
--- a/gcc/m2/gm2-gcc/m2decl.cc
+++ b/gcc/m2/gm2-gcc/m2decl.cc
@@ -211,7 +211,7 @@ tree
 m2decl_BuildEndFunctionDeclaration (location_t location_begin,
                                     location_t location_end, const char *name,
                                     tree returntype, int isexternal,
-                                    int isnested, int ispublic)
+                                    int isnested, int ispublic, int isnoreturn)
 {
   tree fntype;
   tree fndecl;
@@ -244,6 +244,7 @@ m2decl_BuildEndFunctionDeclaration (location_t location_begin,
       = build_decl (location_end, RESULT_DECL, NULL_TREE, returntype);
   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
   TREE_TYPE (fndecl) = fntype;
+  TREE_THIS_VOLATILE (fndecl) = isnoreturn;
 
   DECL_SOURCE_LOCATION (fndecl) = location_begin;
 
diff --git a/gcc/m2/gm2-gcc/m2decl.def b/gcc/m2/gm2-gcc/m2decl.def
index 036f903c..6a19693 100644
--- a/gcc/m2/gm2-gcc/m2decl.def
+++ b/gcc/m2/gm2-gcc/m2decl.def
@@ -149,7 +149,8 @@ PROCEDURE BuildStartFunctionDeclaration (uses_varargs: BOOLEAN) ;
 
 PROCEDURE BuildEndFunctionDeclaration (location_begin, location_end: location_t;
                                        name: ADDRESS; returntype: Tree;
-                                       isexternal, isnested, ispublic: BOOLEAN) : Tree ;
+                                       isexternal, isnested, ispublic,
+                                       isnoreturn: BOOLEAN) : Tree ;
 
 
 (*
diff --git a/gcc/m2/gm2-gcc/m2decl.h b/gcc/m2/gm2-gcc/m2decl.h
index 13ecaaf..19dbb7b 100644
--- a/gcc/m2/gm2-gcc/m2decl.h
+++ b/gcc/m2/gm2-gcc/m2decl.h
@@ -58,7 +58,8 @@ EXTERN void m2decl_RememberVariables (tree l);
 
 EXTERN tree m2decl_BuildEndFunctionDeclaration (
     location_t location_begin, location_t location_end, const char *name,
-    tree returntype, int isexternal, int isnested, int ispublic);
+    tree returntype, int isexternal, int isnested, int ispublic,
+    int isnoreturn);
 EXTERN void m2decl_BuildStartFunctionDeclaration (int uses_varargs);
 EXTERN tree m2decl_BuildParameterDeclaration (location_t location, char *name,
                                               tree type, int isreference);
diff --git a/gcc/m2/gm2-gcc/m2except.cc b/gcc/m2/gm2-gcc/m2except.cc
index 2f43b68..ab7df80 100644
--- a/gcc/m2/gm2-gcc/m2except.cc
+++ b/gcc/m2/gm2-gcc/m2except.cc
@@ -103,18 +103,19 @@ m2except_InitExceptions (location_t location)
 
   m2decl_BuildStartFunctionDeclaration (FALSE);
   fn_rethrow_tree = m2decl_BuildEndFunctionDeclaration (
-      location, location, "__cxa_rethrow", void_type_node, TRUE, FALSE, TRUE);
+     location, location, "__cxa_rethrow", void_type_node, TRUE, FALSE,
+     TRUE, FALSE);
   TREE_NOTHROW (fn_rethrow_tree) = 0;
 
   m2decl_BuildStartFunctionDeclaration (FALSE);
   m2decl_BuildParameterDeclaration (location, NULL, ptr_type_node, FALSE);
   fn_begin_catch_tree = m2decl_BuildEndFunctionDeclaration (
       location, location, "__cxa_begin_catch", ptr_type_node, TRUE, FALSE,
-      TRUE);
+      TRUE, FALSE);
   m2decl_BuildStartFunctionDeclaration (FALSE);
   fn_end_catch_tree = m2decl_BuildEndFunctionDeclaration (
       location, location, "__cxa_end_catch", void_type_node, TRUE, FALSE,
-      TRUE);
+      TRUE, FALSE);
   /* This can throw if the destructor for the exception throws.  */
   TREE_NOTHROW (fn_end_catch_tree) = 0;
 
@@ -130,26 +131,28 @@ m2except_InitExceptions (location_t location)
   m2decl_BuildParameterDeclaration (location, NULL, ptr_type_node, FALSE);
   m2decl_BuildParameterDeclaration (location, NULL, ptr_type_node, FALSE);
   fn_throw_tree = m2decl_BuildEndFunctionDeclaration (
-      location, location, "__cxa_throw", void_type_node, TRUE, FALSE, TRUE);
+      location, location, "__cxa_throw", void_type_node, TRUE, FALSE, TRUE,
+      FALSE);
 
   /* Declare void __cxa_rethrow (void).  */
   m2decl_BuildStartFunctionDeclaration (FALSE);
   fn_rethrow_tree = m2decl_BuildEndFunctionDeclaration (
-      location, location, "__cxa_rethrow", void_type_node, TRUE, FALSE, TRUE);
+     location, location, "__cxa_rethrow", void_type_node, TRUE, FALSE, TRUE,
+     FALSE);
 
   /* Declare void *__cxa_allocate_exception (size_t).  */
   m2decl_BuildStartFunctionDeclaration (FALSE);
   m2decl_BuildParameterDeclaration (location, NULL, size_type_node, FALSE);
   fn_allocate_exception_tree = m2decl_BuildEndFunctionDeclaration (
       location, location, "__cxa_allocate_exception", ptr_type_node, TRUE,
-      FALSE, TRUE);
+      FALSE, TRUE, FALSE);
 
   /* Declare void *__cxa_free_exception (void *).  */
   m2decl_BuildStartFunctionDeclaration (FALSE);
   m2decl_BuildParameterDeclaration (location, NULL, ptr_type_node, FALSE);
   fn_free_exception_tree = m2decl_BuildEndFunctionDeclaration (
       location, location, "__cxa_free_exception", ptr_type_node, TRUE, FALSE,
-      TRUE);
+      TRUE, FALSE);
 
   /* Define integer type exception type which will match C++ int type
      in the C++ runtime library.  */
diff --git a/gcc/m2/gm2-gcc/m2options.h b/gcc/m2/gm2-gcc/m2options.h
index 80c7968..92b4fd5 100644
--- a/gcc/m2/gm2-gcc/m2options.h
+++ b/gcc/m2/gm2-gcc/m2options.h
@@ -38,7 +38,6 @@ along with GNU Modula-2; see the file COPYING3.  If not see
 
 #include "input.h"
 
-EXTERN void M2Options_SetMakeIncludePath (const char *arg);
 EXTERN void M2Options_SetSearchPath (const char *arg);
 EXTERN void M2Options_setdefextension (const char *arg);
 EXTERN void M2Options_setmodextension (const char *arg);
@@ -62,6 +61,8 @@ EXTERN int M2Options_GetWholeValueCheck (void);
 
 EXTERN void M2Options_Setc (int value);
 EXTERN int M2Options_Getc (void);
+EXTERN void M2Options_SetPPOnly (int value);
+EXTERN int M2Options_GetPPOnly (void);
 
 EXTERN void M2Options_SetUselist (int value, const char *filename);
 EXTERN void M2Options_SetAutoInit (int value);
@@ -113,6 +114,7 @@ EXTERN void M2Options_SetStrictTypeChecking (int value);
 EXTERN void M2Options_SetWall (int value);
 EXTERN void M2Options_SetSaveTemps (int value);
 EXTERN void M2Options_SetSaveTempsDir (const char *arg);
+EXTERN void M2Options_SetDumpDir (const char *arg);
 EXTERN int M2Options_GetSaveTemps (void);
 EXTERN void M2Options_SetScaffoldStatic (int value);
 EXTERN void M2Options_SetScaffoldDynamic (int value);
@@ -122,6 +124,14 @@ EXTERN void M2Options_SetGenModuleList (int value, const char *filename);
 EXTERN void M2Options_SetShared (int value);
 EXTERN void M2Options_SetB (const char *arg);
 EXTERN char *M2Options_GetB (void);
+EXTERN void M2Options_SetMD (const char *arg);
+EXTERN char *M2Options_GetMD (void);
+EXTERN void M2Options_SetMMD (const char *arg);
+EXTERN char *M2Options_GetMMD (void);
+EXTERN void M2Options_SetMQ (const char *arg);
+EXTERN char *M2Options_GetMQ (void);
+EXTERN void M2Options_SetObj (const char *arg);
+EXTERN char *M2Options_GetObj (void);
 
 #undef EXTERN
 #endif /* m2options_h.  */
diff --git a/gcc/m2/gm2-gcc/m2statement.cc b/gcc/m2/gm2-gcc/m2statement.cc
index 74956da..c3307db 100644
--- a/gcc/m2/gm2-gcc/m2statement.cc
+++ b/gcc/m2/gm2-gcc/m2statement.cc
@@ -84,23 +84,6 @@ m2statement_BuildStartFunctionCode (location_t location, tree fndecl,
   DECL_DECLARED_INLINE_P (fndecl) = 0; /* isinline;  */
 }
 
-static void
-gm2_gimplify_function_node (tree fndecl)
-{
-  /* Convert all nested functions to GIMPLE now.  We do things in this
-     order so that items like VLA sizes are expanded properly in the
-     context of the correct function.  */
-  struct cgraph_node *cgn;
-
-  dump_function (TDI_original, fndecl);
-  gimplify_function_tree (fndecl);
-
-  cgn = cgraph_node::get_create (fndecl);
-  for (cgn = first_nested_function (cgn);
-       cgn != NULL; cgn = next_nested_function (cgn))
-    gm2_gimplify_function_node (cgn->decl);
-}
-
 /* BuildEndFunctionCode - generates the function epilogue.  */
 
 void
diff --git a/gcc/m2/gm2-gcc/m2type.cc b/gcc/m2/gm2-gcc/m2type.cc
index ad5064f..634fad8 100644
--- a/gcc/m2/gm2-gcc/m2type.cc
+++ b/gcc/m2/gm2-gcc/m2type.cc
@@ -36,6 +36,7 @@ along with GNU Modula-2; see the file COPYING3.  If not see
 #include "m2tree.h"
 #include "m2treelib.h"
 #include "m2type.h"
+#include "m2options.h"
 
 #undef USE_BOOLEAN
 static int broken_set_debugging_info = TRUE;
@@ -1782,6 +1783,9 @@ m2type_InitBaseTypes (location_t location)
 
   m2_packed_boolean_type_node = build_nonstandard_integer_type (1, TRUE);
 
+  if (M2Options_GetPPOnly ())
+    return;
+
   m2builtins_init (location);
   m2except_InitExceptions (location);
   m2expr_init (location);
diff --git a/gcc/m2/gm2-lang.cc b/gcc/m2/gm2-lang.cc
index b812327..999c57c 100644
--- a/gcc/m2/gm2-lang.cc
+++ b/gcc/m2/gm2-lang.cc
@@ -20,6 +20,7 @@ along with GNU Modula-2; see the file COPYING.  If not, write to the
 Free Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
 02110-1301, USA.  */
 
+#define INCLUDE_VECTOR
 #include "gm2-gcc/gcc-consolidation.h"
 
 #include "langhooks-def.h" /* FIXME: for lhd_set_decl_assembler_name.  */
@@ -45,6 +46,18 @@ static void write_globals (void);
 
 static int insideCppArgs = FALSE;
 
+/* We default to pim in the absence of fiso.  */
+static bool iso = false;
+
+/* The language include paths are based on the libraries in use.  */
+static bool allow_libraries = true;
+static const char *flibs = nullptr;
+static const char *iprefix = nullptr;
+static const char *imultilib = nullptr;
+static std::vector<const char*>Ipaths;
+static std::vector<const char*>isystem;
+static std::vector<const char*>iquote;
+
 #define EXPR_STMT_EXPR(NODE) TREE_OPERAND (EXPR_STMT_CHECK (NODE), 0)
 
 /* start of new stuff.  */
@@ -94,6 +107,8 @@ struct GTY (()) language_function
 
 /* Language hooks.  */
 
+static void gm2_langhook_parse_file (void);
+
 bool
 gm2_langhook_init (void)
 {
@@ -107,6 +122,13 @@ gm2_langhook_init (void)
 
   /* GNU Modula-2 uses exceptions.  */
   using_eh_for_cleanups ();
+
+  if (M2Options_GetPPOnly ())
+    {
+      /* preprocess the file here.  */
+      gm2_langhook_parse_file ();
+      return false; /* Finish now, no further compilation.  */
+    }
   return true;
 }
 
@@ -142,27 +164,150 @@ gm2_langhook_init_options_struct (struct gcc_options *opts)
 
 static vec<bool> filename_cpp;
 
+/* Build the C preprocessor command line here, since we need to include
+   options that are not passed to the handle_option function.  */
+
 void
 gm2_langhook_init_options (unsigned int decoded_options_count,
                            struct cl_decoded_option *decoded_options)
 {
   unsigned int i;
   bool in_cpp_args = false;
+  bool building_cpp_command = false;
 
   for (i = 1; i < decoded_options_count; i++)
     {
-      switch (decoded_options[i].opt_index)
-        {
-        case OPT_fcpp_begin:
-          in_cpp_args = true;
-          break;
-        case OPT_fcpp_end:
-          in_cpp_args = false;
-          break;
-        case OPT_SPECIAL_input_file:
-        case OPT_SPECIAL_program_name:
-          filename_cpp.safe_push (in_cpp_args);
-        }
+      enum opt_code code = (enum opt_code)decoded_options[i].opt_index;
+      const struct cl_option *option = &cl_options[code];
+      const char *opt = (const char *)option->opt_text;
+      const char *arg = decoded_options[i].arg;
+      HOST_WIDE_INT value = decoded_options[i].value;
+      switch (code)
+	{
+	case OPT_fcpp:
+	  gcc_checking_assert (building_cpp_command);
+	  break;
+	case OPT_fcpp_begin:
+	  in_cpp_args = true;
+	  building_cpp_command = true;
+	  break;
+	case OPT_fcpp_end:
+	  in_cpp_args = false;
+	  break;
+	case OPT_SPECIAL_input_file:
+	  filename_cpp.safe_push (in_cpp_args);
+	  break;
+
+	/* C and driver opts that are not passed to the preprocessor for
+	   modula-2, but that we use internally for building preprocesor
+	   command lines.  */
+	case OPT_B:
+	  M2Options_SetB (arg);
+	  break;
+	case OPT_c:
+	  M2Options_Setc (value);
+	  break;
+	case OPT_dumpdir:
+	  if (building_cpp_command)
+	    M2Options_SetDumpDir (arg);
+	  break;
+	case OPT_save_temps:
+	  if (building_cpp_command)
+	    M2Options_SetSaveTemps (value);
+	  break;
+	case OPT_save_temps_:
+	  if (building_cpp_command)
+	    /* Also sets SaveTemps. */
+	    M2Options_SetSaveTempsDir (arg);
+	  break;
+
+	case OPT_E:
+	  if (!in_cpp_args)
+	    {
+	      M2Options_SetPPOnly (value);
+	      building_cpp_command = true;
+	    }
+	  M2Options_CppArg (opt, arg, (option->flags & CL_JOINED)
+			      && !(option->flags & CL_SEPARATE));
+	  break;
+	case OPT_M:
+	case OPT_MM:
+	  gcc_checking_assert (building_cpp_command);
+	  M2Options_SetPPOnly (value);
+	  /* This is a preprocessor command.  */
+	  M2Options_CppArg (opt, arg, (option->flags & CL_JOINED)
+			      && !(option->flags & CL_SEPARATE));
+	  break;
+
+	/* We can only use MQ when the command line is either PP-only, or
+	   when there is a MD/MMD on it.  */
+	case OPT_MQ:
+	  M2Options_SetMQ (arg);
+	  break;
+
+	case OPT_o:
+	  M2Options_SetObj (arg);
+	  break;
+
+	/* C and driver options that we ignore for the preprocessor lines.  */
+	case OPT_fpch_deps:
+	case OPT_fpch_preprocess:
+	  break;
+
+	case OPT_fplugin_:
+	  /* FIXME: We might need to handle this specially, since the modula-2
+	     plugin is not usable here, but others might be.
+	     For now skip all plugins to avoid fails with the m2 one.  */
+	  break;
+
+	/* Preprocessor arguments with a following filename, we add these
+	   back to the main file preprocess line, but not to dependents
+	   TODO Handle MF.  */
+	case OPT_MD:
+	  M2Options_SetMD (arg);
+	  break;
+	case OPT_MMD:
+	  M2Options_SetMMD (arg);
+	  break;
+
+	/* Modula 2 claimed options we pass to the preprocessor.  */
+	case OPT_ansi:
+	case OPT_traditional_cpp:
+	  if (building_cpp_command)
+	    M2Options_CppArg (opt, arg, (option->flags & CL_JOINED)
+			      && !(option->flags & CL_SEPARATE));
+	  break;
+
+	/* Options we act on and also pass to the preprocessor.  */
+	case OPT_O:
+	  M2Options_SetOptimizing (value);
+	  if (building_cpp_command)
+	    M2Options_CppArg (opt, arg, (option->flags & CL_JOINED)
+			      && !(option->flags & CL_SEPARATE));
+	  break;
+	case OPT_quiet:
+	  M2Options_SetQuiet (value);
+	  if (building_cpp_command)
+	    M2Options_CppArg (opt, arg, (option->flags & CL_JOINED)
+			      && !(option->flags & CL_SEPARATE));
+	  break;
+	case OPT_v:
+	  M2Options_SetVerbose (value);
+	  /* FALLTHROUGH */
+	default:
+	  /* We handled input files above.  */
+	  if (code >= N_OPTS)
+	    break;
+	  /* Do not pass Modula-2 args to the preprocessor, any that we care
+	     about here should already have been handled above.  */
+	  if (option->flags & CL_ModulaX2)
+	    break;
+	  /* Otherwise, add this to the CPP command line.  */
+	  if (building_cpp_command)
+	    M2Options_CppArg (opt, arg, (option->flags & CL_JOINED)
+			      && !(option->flags & CL_SEPARATE));
+	  break;
+	}
     }
   filename_cpp.safe_push (false);
 }
@@ -184,48 +329,43 @@ gm2_langhook_handle_option (
 {
   enum opt_code code = (enum opt_code)scode;
 
+  const struct cl_option *option = &cl_options[scode];
+  const char *opt = (const char *)option->opt_text;
   /* ignore file names.  */
   if (code == N_OPTS)
     return 1;
 
   switch (code)
     {
-    case OPT_B:
-      M2Options_SetB (arg);
-      return 1;
-    case OPT_c:
-      M2Options_Setc (value);
-      return 1;
     case OPT_I:
-      if (insideCppArgs)
-        {
-          const struct cl_option *option = &cl_options[scode];
-          const char *opt = (const char *)option->opt_text;
-          M2Options_CppArg (opt, arg, TRUE);
-        }
-      else
-        M2Options_SetSearchPath (arg);
+      Ipaths.push_back (arg);
       return 1;
     case OPT_fiso:
       M2Options_SetISO (value);
+      iso = value;
       return 1;
     case OPT_fpim:
       M2Options_SetPIM (value);
+      iso = value ? false : iso;
       return 1;
     case OPT_fpim2:
       M2Options_SetPIM2 (value);
+      iso = value ? false : iso;
       return 1;
     case OPT_fpim3:
       M2Options_SetPIM3 (value);
+      iso = value ? false : iso;
       return 1;
     case OPT_fpim4:
       M2Options_SetPIM4 (value);
+      iso = value ? false : iso;
       return 1;
     case OPT_fpositive_mod_floor_div:
       M2Options_SetPositiveModFloor (value);
       return 1;
     case OPT_flibs_:
-      /* handled in the gm2 driver.  */
+      allow_libraries = value;
+      flibs = arg;
       return 1;
     case OPT_fgen_module_list_:
       M2Options_SetGenModuleList (value, arg);
@@ -338,6 +478,9 @@ gm2_langhook_handle_option (
     case OPT_fcpp:
       M2Options_SetCpp (value);
       return 1;
+    case OPT_fpreprocessed:
+      /* Provided for compatibility; ignore for now.  */
+      return 1;
     case OPT_fcpp_begin:
       insideCppArgs = TRUE;
       return 1;
@@ -374,12 +517,27 @@ gm2_langhook_handle_option (
     case OPT_fm2_g:
       M2Options_SetM2g (value);
       return 1;
-    case OPT_O:
-      M2Options_SetOptimizing (value);
+      break;
+    case OPT_iprefix:
+      iprefix = arg;
       return 1;
-    case OPT_quiet:
-      M2Options_SetQuiet (value);
+      break;
+    case OPT_imultilib:
+      imultilib = arg;
       return 1;
+      break;
+    case OPT_isystem:
+      isystem.push_back (arg);
+      return 1;
+      break;
+    case OPT_iquote:
+      iquote.push_back (arg);
+      return 1;
+      break;
+    case OPT_isysroot:
+      /* Otherwise, ignored, at least for now. */
+      return 1;
+      break;
     case OPT_fm2_whole_program:
       M2Options_SetWholeProgram (value);
       return 1;
@@ -401,29 +559,82 @@ gm2_langhook_handle_option (
         }
       else
         return 0;
-    case OPT_save_temps:
-      M2Options_SetSaveTemps (value);
-      return 1;
-    case OPT_save_temps_:
-      M2Options_SetSaveTempsDir (arg);
-      return 1;
-    case OPT_v:
-      M2Options_SetVerbose (value);
-      return 1;
     default:
       if (insideCppArgs)
-        {
-          const struct cl_option *option = &cl_options[scode];
-          const char *opt = (const char *)option->opt_text;
-
-          M2Options_CppArg (opt, arg, TRUE);
-          return 1;
-        }
-      return 0;
+	/* Handled in gm2_langhook_init_options ().  */
+	return 1;
+      else if (option->flags & CL_DRIVER)
+	/* Driver options (unless specifically claimed above) should be handled
+	   in gm2_langhook_init_options ().  */
+	return 1;
+      else if (option->flags & CL_C)
+	/* C options (unless specifically claimed above) should be handled
+	   in gm2_langhook_init_options ().  */
+	return 1;
+      break;
     }
   return 0;
 }
 
+/* This prefixes LIBNAME with the current compiler prefix (if it has been
+   relocated) or the LIBSUBDIR, if not.  */
+static void
+add_one_import_path (const char *libname)
+{
+  const char *libpath = iprefix ? iprefix : LIBSUBDIR;
+  const char dir_sep[] = {DIR_SEPARATOR, (char)0};
+  size_t dir_sep_size = strlen (dir_sep);
+  unsigned int mlib_len = 0;
+
+  if (imultilib)
+    {
+      mlib_len = strlen (imultilib);
+      mlib_len += strlen (dir_sep);
+    }
+
+  char *lib = (char *)alloca (strlen (libpath) + dir_sep_size
+			      + strlen ("m2") + dir_sep_size
+			      + strlen (libname) + 1
+			      + mlib_len + 1);
+  strcpy (lib, libpath);
+  /* iprefix has a trailing dir separator, LIBSUBDIR does not.  */
+  if (!iprefix)
+    strcat (lib, dir_sep);
+
+  if (imultilib)
+    {
+      strcat (lib, imultilib);
+      strcat (lib, dir_sep);
+    }
+  strcat (lib, "m2");
+  strcat (lib, dir_sep);
+  strcat (lib, libname);
+  M2Options_SetSearchPath (lib);
+}
+
+/* For each comma-separated standard library name in LIBLIST, add the
+   corresponding include path.  */
+static void
+add_m2_import_paths (const char *liblist)
+{
+  while (*liblist != 0 && *liblist != '-')
+    {
+      const char *comma = strstr (liblist, ",");
+      size_t len;
+      if (comma)
+	len = comma - liblist;
+      else
+	len = strlen (liblist);
+      char *libname = (char *) alloca (len+1);
+      strncpy (libname, liblist, len);
+      libname[len] = 0;
+      add_one_import_path (libname);
+      liblist += len;
+      if (*liblist == ',')
+	liblist++;
+    }
+}
+
 /* Run after parsing options.  */
 
 static bool
@@ -435,8 +646,43 @@ gm2_langhook_post_options (const char **pfilename)
   M2Options_FinaliseOptions ();
   main_input_filename = filename;
 
-  /* Returning false means that the backend should be used.  */
-  return false;
+  /* Add the include paths as per the libraries specified.
+     NOTE: This assumes that the driver has validated the input and makes
+     no attempt to be defensive of nonsense input in flibs=.  */
+  if (allow_libraries)
+    {
+      if (!flibs)
+	{
+	  if (iso)
+	    flibs = "m2iso,m2cor,m2pim,m2log";
+	  else
+	    flibs = "m2pim,m2iso,m2cor,m2log";
+	}
+    }
+
+  /* Add search paths.
+     We are not handling all of the cases yet (e.g idirafter).
+     This (barring the missing cases) is intended to follow the directory
+     search rules used for c-family.  It would be less confusing if the
+     presence of absence of these search paths was not dependent on the
+     flibs= option. */
+
+  for (auto *s : iquote)
+    M2Options_SetSearchPath (s);
+  iquote.clear();
+  for (auto *s : Ipaths)
+    M2Options_SetSearchPath (s);
+  Ipaths.clear();
+  for (auto *s : isystem)
+    M2Options_SetSearchPath (s);
+  isystem.clear();
+  /* FIXME: this is not a good way to suppress the addition of the import
+     paths.  */
+  if (allow_libraries)
+    add_m2_import_paths (flibs);
+
+ /* Returning false means that the backend should be used.  */
+  return M2Options_GetPPOnly ();
 }
 
 /* Call the compiler for every source filename on the command line.  */
@@ -459,7 +705,8 @@ static void
 gm2_langhook_parse_file (void)
 {
   gm2_parse_input_files (in_fnames, num_in_fnames);
-  write_globals ();
+  if (!M2Options_GetPPOnly ())
+    write_globals ();
 }
 
 static tree
diff --git a/gcc/m2/gm2-libs-iso/M2RTS.def b/gcc/m2/gm2-libs-iso/M2RTS.def
index ce9c6ab..6958fd4 100644
--- a/gcc/m2/gm2-libs-iso/M2RTS.def
+++ b/gcc/m2/gm2-libs-iso/M2RTS.def
@@ -111,14 +111,25 @@ PROCEDURE HALT ([exitcode: INTEGER = -1]) ;
 
 (*
    Halt - provides a more user friendly version of HALT, which takes
-          four parameters to aid debugging.
+           four parameters to aid debugging.  It writes an error message
+           to stderr and calls exit (1).
 *)
 
-PROCEDURE Halt (file: ARRAY OF CHAR; line: CARDINAL;
+PROCEDURE Halt (filename: ARRAY OF CHAR; line: CARDINAL;
                 function: ARRAY OF CHAR; description: ARRAY OF CHAR) ;
 
 
 (*
+   HaltC - provides a more user friendly version of HALT, which takes
+           four parameters to aid debugging.  It writes an error message
+           to stderr and calls exit (1).
+*)
+
+PROCEDURE HaltC (filename: ADDRESS; line: CARDINAL;
+                 function, description: ADDRESS) ;
+
+
+(*
    ExitOnHalt - if HALT is executed then call exit with the exit code, e.
 *)
 
@@ -130,7 +141,7 @@ PROCEDURE ExitOnHalt (e: INTEGER) ;
 *)
 
 PROCEDURE ErrorMessage (message: ARRAY OF CHAR;
-                        file: ARRAY OF CHAR;
+                        filename: ARRAY OF CHAR;
                         line: CARDINAL;
                         function: ARRAY OF CHAR) ;
 
diff --git a/gcc/m2/gm2-libs-iso/M2RTS.mod b/gcc/m2/gm2-libs-iso/M2RTS.mod
index 2448c26..cbe70a9 100644
--- a/gcc/m2/gm2-libs-iso/M2RTS.mod
+++ b/gcc/m2/gm2-libs-iso/M2RTS.mod
@@ -27,7 +27,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 IMPLEMENTATION MODULE M2RTS ;
 
 
-FROM libc IMPORT abort, exit, write, getenv, printf ;
+FROM libc IMPORT abort, exit, write, getenv, printf, strlen ;
 (* FROM Builtins IMPORT strncmp, strcmp ;  not available during bootstrap.  *)
 FROM NumberIO IMPORT CardToStr ;
 FROM StrLib IMPORT StrCopy, StrLen, StrEqual ;
@@ -39,6 +39,9 @@ IMPORT RTExceptions ;
 IMPORT M2EXCEPTION ;
 IMPORT M2Dependent ;
 
+CONST
+   stderrFd = 2 ;
+
 TYPE
    PtrToChar = POINTER TO CHAR ;
 
@@ -255,24 +258,36 @@ PROCEDURE ErrorString (a: ARRAY OF CHAR) ;
 VAR
    n: INTEGER ;
 BEGIN
-   n := write (2, ADR (a), StrLen (a))
+   n := write (stderrFd, ADR (a), StrLen (a))
 END ErrorString ;
 
 
 (*
+   ErrorStringC - writes a string to stderr.
+*)
+
+PROCEDURE ErrorStringC (str: ADDRESS) ;
+VAR
+   len: INTEGER ;
+BEGIN
+   len := write (stderrFd, str, strlen (str))
+END ErrorStringC ;
+
+
+(*
    ErrorMessage - emits an error message to stderr and then calls exit (1).
 *)
 
 PROCEDURE ErrorMessage (message: ARRAY OF CHAR;
-                        file: ARRAY OF CHAR;
+                        filename: ARRAY OF CHAR;
                         line: CARDINAL;
                         function: ARRAY OF CHAR) <* noreturn *> ;
 VAR
-   LineNo: ARRAY [0..10] OF CHAR ;
+   buffer: ARRAY [0..10] OF CHAR ;
 BEGIN
-   ErrorString (file) ; ErrorString(':') ;
-   CardToStr (line, 0, LineNo) ;
-   ErrorString (LineNo) ; ErrorString(':') ;
+   ErrorString (filename) ; ErrorString(':') ;
+   CardToStr (line, 0, buffer) ;
+   ErrorString (buffer) ; ErrorString(':') ;
    IF NOT StrEqual (function, '')
    THEN
       ErrorString ('in ') ;
@@ -280,22 +295,61 @@ BEGIN
       ErrorString (' has caused ') ;
    END ;
    ErrorString (message) ;
-   LineNo[0] := nl ; LineNo[1] := nul ;
-   ErrorString (LineNo) ;
+   buffer[0] := nl ; buffer[1] := nul ;
+   ErrorString (buffer) ;
    exit (1)
 END ErrorMessage ;
 
 
 (*
+   ErrorMessageC - emits an error message to stderr and then calls exit (1).
+*)
+
+PROCEDURE ErrorMessageC (message, filename: ADDRESS;
+                         line: CARDINAL;
+                         function: ADDRESS) <* noreturn *> ;
+VAR
+   buffer: ARRAY [0..10] OF CHAR ;
+BEGIN
+   ErrorStringC (filename) ; ErrorString (':') ;
+   CardToStr (line, 0, buffer) ;
+   ErrorString (buffer) ; ErrorString(':') ;
+   IF strlen (function) > 0
+   THEN
+      ErrorString ('in ') ;
+      ErrorStringC (function) ;
+      ErrorString (' has caused ') ;
+   END ;
+   ErrorStringC (message) ;
+   buffer[0] := nl ; buffer[1] := nul ;
+   ErrorString (buffer) ;
+   exit (1)
+END ErrorMessageC ;
+
+
+(*
+   HaltC - provides a more user friendly version of HALT, which takes
+           four parameters to aid debugging.  It writes an error message
+           to stderr and calls exit (1).
+*)
+
+PROCEDURE HaltC (filename: ADDRESS; line: CARDINAL;
+                 function, description: ADDRESS) ;
+BEGIN
+   ErrorMessageC (description, filename, line, function)
+END HaltC ;
+
+
+(*
    Halt - provides a more user friendly version of HALT, which takes
-          four parameters to aid debugging.
+          four parameters to aid debugging.  It writes an error message
+          to stderr and calls exit (1).
 *)
 
-PROCEDURE Halt (file: ARRAY OF CHAR; line: CARDINAL;
+PROCEDURE Halt (filename: ARRAY OF CHAR; line: CARDINAL;
                 function: ARRAY OF CHAR; description: ARRAY OF CHAR) ;
 BEGIN
-   ErrorMessage (description, file, line, function) ;
-   HALT
+   ErrorMessage (description, filename, line, function)
 END Halt ;
 
 
diff --git a/gcc/m2/gm2-libs-iso/Preemptive.mod b/gcc/m2/gm2-libs-iso/Preemptive.mod
index 53952e1..44aa62b 100644
--- a/gcc/m2/gm2-libs-iso/Preemptive.mod
+++ b/gcc/m2/gm2-libs-iso/Preemptive.mod
@@ -33,6 +33,9 @@ FROM libc IMPORT printf ;
 
 CONST
    debugging = FALSE ;
+   (* The space we request becomes part of a stack request, which generally
+      has constraints on size and alignment.  *)
+   extraWorkSpace = 10 * 1024 * 1024 ;
 
 (*
    timer - the timer process which runs at maximum scheduling priority with
@@ -107,7 +110,7 @@ BEGIN
    IF NOT init
    THEN
       init := TRUE ;
-      Create (timer, 10000000, MAX (Urgency), NIL, timerId) ;
+      Create (timer, extraWorkSpace, MAX (Urgency), NIL, timerId) ;
       Activate (timerId)
    END
 END initPreemptive ;
diff --git a/gcc/m2/gm2-libs-iso/RTco.def b/gcc/m2/gm2-libs-iso/RTco.def
index 33452ba..5285a7d 100644
--- a/gcc/m2/gm2-libs-iso/RTco.def
+++ b/gcc/m2/gm2-libs-iso/RTco.def
@@ -24,10 +24,12 @@ a copy of the GCC Runtime Library Exception along with this program;
 see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  *)
 
-DEFINITION MODULE RTco ;
+DEFINITION MODULE FOR "C" RTco ;
 
 FROM SYSTEM IMPORT ADDRESS ;
 
+IMPORT RTentity ;  (* Imported so the initialization call graph
+                      understands that RTco.cc depends upon RTentity.  *)
 
 (* init initializes the module and allows the application to lazily invoke threads.  *)
 
diff --git a/gcc/m2/gm2-libs-pim/BitBlockOps.def b/gcc/m2/gm2-libs-log/BitBlockOps.def
index bb92811..bb92811 100644
--- a/gcc/m2/gm2-libs-pim/BitBlockOps.def
+++ b/gcc/m2/gm2-libs-log/BitBlockOps.def
diff --git a/gcc/m2/gm2-libs-pim/BitBlockOps.mod b/gcc/m2/gm2-libs-log/BitBlockOps.mod
index 863680f..863680f 100644
--- a/gcc/m2/gm2-libs-pim/BitBlockOps.mod
+++ b/gcc/m2/gm2-libs-log/BitBlockOps.mod
diff --git a/gcc/m2/gm2-libs-pim/BitByteOps.def b/gcc/m2/gm2-libs-log/BitByteOps.def
index e6344c2..e6344c2 100644
--- a/gcc/m2/gm2-libs-pim/BitByteOps.def
+++ b/gcc/m2/gm2-libs-log/BitByteOps.def
diff --git a/gcc/m2/gm2-libs-pim/BitByteOps.mod b/gcc/m2/gm2-libs-log/BitByteOps.mod
index 318a2e3..318a2e3 100644
--- a/gcc/m2/gm2-libs-pim/BitByteOps.mod
+++ b/gcc/m2/gm2-libs-log/BitByteOps.mod
diff --git a/gcc/m2/gm2-libs-pim/BitWordOps.def b/gcc/m2/gm2-libs-log/BitWordOps.def
index 899bb0a..899bb0a 100644
--- a/gcc/m2/gm2-libs-pim/BitWordOps.def
+++ b/gcc/m2/gm2-libs-log/BitWordOps.def
diff --git a/gcc/m2/gm2-libs-pim/BitWordOps.mod b/gcc/m2/gm2-libs-log/BitWordOps.mod
index 9dd94e7..9dd94e7 100644
--- a/gcc/m2/gm2-libs-pim/BitWordOps.mod
+++ b/gcc/m2/gm2-libs-log/BitWordOps.mod
diff --git a/gcc/m2/gm2-libs-pim/BlockOps.def b/gcc/m2/gm2-libs-log/BlockOps.def
index 8cd1ebd..8cd1ebd 100644
--- a/gcc/m2/gm2-libs-pim/BlockOps.def
+++ b/gcc/m2/gm2-libs-log/BlockOps.def
diff --git a/gcc/m2/gm2-libs-pim/BlockOps.mod b/gcc/m2/gm2-libs-log/BlockOps.mod
index eab6938..eab6938 100644
--- a/gcc/m2/gm2-libs-pim/BlockOps.mod
+++ b/gcc/m2/gm2-libs-log/BlockOps.mod
diff --git a/gcc/m2/gm2-libs-pim/Break.c b/gcc/m2/gm2-libs-log/Break.c
index ecb33b0..ecb33b0 100644
--- a/gcc/m2/gm2-libs-pim/Break.c
+++ b/gcc/m2/gm2-libs-log/Break.c
diff --git a/gcc/m2/gm2-libs-pim/Break.def b/gcc/m2/gm2-libs-log/Break.def
index 271384c..271384c 100644
--- a/gcc/m2/gm2-libs-pim/Break.def
+++ b/gcc/m2/gm2-libs-log/Break.def
diff --git a/gcc/m2/gm2-libs-pim/CardinalIO.def b/gcc/m2/gm2-libs-log/CardinalIO.def
index d6b4eec..d6b4eec 100644
--- a/gcc/m2/gm2-libs-pim/CardinalIO.def
+++ b/gcc/m2/gm2-libs-log/CardinalIO.def
diff --git a/gcc/m2/gm2-libs-pim/CardinalIO.mod b/gcc/m2/gm2-libs-log/CardinalIO.mod
index 5f7e750..5f7e750 100644
--- a/gcc/m2/gm2-libs-pim/CardinalIO.mod
+++ b/gcc/m2/gm2-libs-log/CardinalIO.mod
diff --git a/gcc/m2/gm2-libs-pim/Conversions.def b/gcc/m2/gm2-libs-log/Conversions.def
index d178e05..d178e05 100644
--- a/gcc/m2/gm2-libs-pim/Conversions.def
+++ b/gcc/m2/gm2-libs-log/Conversions.def
diff --git a/gcc/m2/gm2-libs-pim/Conversions.mod b/gcc/m2/gm2-libs-log/Conversions.mod
index 1c8b893..1c8b893 100644
--- a/gcc/m2/gm2-libs-pim/Conversions.mod
+++ b/gcc/m2/gm2-libs-log/Conversions.mod
diff --git a/gcc/m2/gm2-libs-pim/DebugPMD.def b/gcc/m2/gm2-libs-log/DebugPMD.def
index 9a3adf6..9a3adf6 100644
--- a/gcc/m2/gm2-libs-pim/DebugPMD.def
+++ b/gcc/m2/gm2-libs-log/DebugPMD.def
diff --git a/gcc/m2/gm2-libs-pim/DebugPMD.mod b/gcc/m2/gm2-libs-log/DebugPMD.mod
index 12a86ca..12a86ca 100644
--- a/gcc/m2/gm2-libs-pim/DebugPMD.mod
+++ b/gcc/m2/gm2-libs-log/DebugPMD.mod
diff --git a/gcc/m2/gm2-libs-pim/DebugTrace.def b/gcc/m2/gm2-libs-log/DebugTrace.def
index 9a00b71..9a00b71 100644
--- a/gcc/m2/gm2-libs-pim/DebugTrace.def
+++ b/gcc/m2/gm2-libs-log/DebugTrace.def
diff --git a/gcc/m2/gm2-libs-pim/DebugTrace.mod b/gcc/m2/gm2-libs-log/DebugTrace.mod
index 10cf797..10cf797 100644
--- a/gcc/m2/gm2-libs-pim/DebugTrace.mod
+++ b/gcc/m2/gm2-libs-log/DebugTrace.mod
diff --git a/gcc/m2/gm2-libs-pim/Delay.def b/gcc/m2/gm2-libs-log/Delay.def
index ccb65e2..ccb65e2 100644
--- a/gcc/m2/gm2-libs-pim/Delay.def
+++ b/gcc/m2/gm2-libs-log/Delay.def
diff --git a/gcc/m2/gm2-libs-pim/Delay.mod b/gcc/m2/gm2-libs-log/Delay.mod
index e8e0ee1..e8e0ee1 100644
--- a/gcc/m2/gm2-libs-pim/Delay.mod
+++ b/gcc/m2/gm2-libs-log/Delay.mod
diff --git a/gcc/m2/gm2-libs-pim/Display.def b/gcc/m2/gm2-libs-log/Display.def
index 7c55971..7c55971 100644
--- a/gcc/m2/gm2-libs-pim/Display.def
+++ b/gcc/m2/gm2-libs-log/Display.def
diff --git a/gcc/m2/gm2-libs-pim/Display.mod b/gcc/m2/gm2-libs-log/Display.mod
index 8006642..8006642 100644
--- a/gcc/m2/gm2-libs-pim/Display.mod
+++ b/gcc/m2/gm2-libs-log/Display.mod
diff --git a/gcc/m2/gm2-libs-pim/ErrorCode.def b/gcc/m2/gm2-libs-log/ErrorCode.def
index 8be1fc2..8be1fc2 100644
--- a/gcc/m2/gm2-libs-pim/ErrorCode.def
+++ b/gcc/m2/gm2-libs-log/ErrorCode.def
diff --git a/gcc/m2/gm2-libs-pim/ErrorCode.mod b/gcc/m2/gm2-libs-log/ErrorCode.mod
index 37b7945..37b7945 100644
--- a/gcc/m2/gm2-libs-pim/ErrorCode.mod
+++ b/gcc/m2/gm2-libs-log/ErrorCode.mod
diff --git a/gcc/m2/gm2-libs-pim/FileSystem.def b/gcc/m2/gm2-libs-log/FileSystem.def
index 784c683..784c683 100644
--- a/gcc/m2/gm2-libs-pim/FileSystem.def
+++ b/gcc/m2/gm2-libs-log/FileSystem.def
diff --git a/gcc/m2/gm2-libs-pim/FileSystem.mod b/gcc/m2/gm2-libs-log/FileSystem.mod
index 9f08819..9f08819 100644
--- a/gcc/m2/gm2-libs-pim/FileSystem.mod
+++ b/gcc/m2/gm2-libs-log/FileSystem.mod
diff --git a/gcc/m2/gm2-libs-pim/FloatingUtilities.def b/gcc/m2/gm2-libs-log/FloatingUtilities.def
index f49f8b8..f49f8b8 100644
--- a/gcc/m2/gm2-libs-pim/FloatingUtilities.def
+++ b/gcc/m2/gm2-libs-log/FloatingUtilities.def
diff --git a/gcc/m2/gm2-libs-pim/FloatingUtilities.mod b/gcc/m2/gm2-libs-log/FloatingUtilities.mod
index 61fc1b3..61fc1b3 100644
--- a/gcc/m2/gm2-libs-pim/FloatingUtilities.mod
+++ b/gcc/m2/gm2-libs-log/FloatingUtilities.mod
diff --git a/gcc/m2/gm2-libs-pim/InOut.def b/gcc/m2/gm2-libs-log/InOut.def
index 2358444..2358444 100644
--- a/gcc/m2/gm2-libs-pim/InOut.def
+++ b/gcc/m2/gm2-libs-log/InOut.def
diff --git a/gcc/m2/gm2-libs-pim/InOut.mod b/gcc/m2/gm2-libs-log/InOut.mod
index 517aca2..517aca2 100644
--- a/gcc/m2/gm2-libs-pim/InOut.mod
+++ b/gcc/m2/gm2-libs-log/InOut.mod
diff --git a/gcc/m2/gm2-libs-pim/Keyboard.def b/gcc/m2/gm2-libs-log/Keyboard.def
index e9ebf84..e9ebf84 100644
--- a/gcc/m2/gm2-libs-pim/Keyboard.def
+++ b/gcc/m2/gm2-libs-log/Keyboard.def
diff --git a/gcc/m2/gm2-libs-pim/Keyboard.mod b/gcc/m2/gm2-libs-log/Keyboard.mod
index 7081c5f..7081c5f 100644
--- a/gcc/m2/gm2-libs-pim/Keyboard.mod
+++ b/gcc/m2/gm2-libs-log/Keyboard.mod
diff --git a/gcc/m2/gm2-libs-pim/LongIO.def b/gcc/m2/gm2-libs-log/LongIO.def
index ca37245..ca37245 100644
--- a/gcc/m2/gm2-libs-pim/LongIO.def
+++ b/gcc/m2/gm2-libs-log/LongIO.def
diff --git a/gcc/m2/gm2-libs-pim/LongIO.mod b/gcc/m2/gm2-libs-log/LongIO.mod
index f9f598f..f9f598f 100644
--- a/gcc/m2/gm2-libs-pim/LongIO.mod
+++ b/gcc/m2/gm2-libs-log/LongIO.mod
diff --git a/gcc/m2/gm2-libs-pim/NumberConversion.def b/gcc/m2/gm2-libs-log/NumberConversion.def
index 4bd0697..4bd0697 100644
--- a/gcc/m2/gm2-libs-pim/NumberConversion.def
+++ b/gcc/m2/gm2-libs-log/NumberConversion.def
diff --git a/gcc/m2/gm2-libs-pim/NumberConversion.mod b/gcc/m2/gm2-libs-log/NumberConversion.mod
index 634e543..634e543 100644
--- a/gcc/m2/gm2-libs-pim/NumberConversion.mod
+++ b/gcc/m2/gm2-libs-log/NumberConversion.mod
diff --git a/gcc/m2/gm2-libs-pim/README.texi b/gcc/m2/gm2-libs-log/README.texi
index 4ea3c11..4ea3c11 100644
--- a/gcc/m2/gm2-libs-pim/README.texi
+++ b/gcc/m2/gm2-libs-log/README.texi
diff --git a/gcc/m2/gm2-libs-pim/Random.def b/gcc/m2/gm2-libs-log/Random.def
index bc7fa4b..bc7fa4b 100644
--- a/gcc/m2/gm2-libs-pim/Random.def
+++ b/gcc/m2/gm2-libs-log/Random.def
diff --git a/gcc/m2/gm2-libs-pim/Random.mod b/gcc/m2/gm2-libs-log/Random.mod
index e50dfbf..e50dfbf 100644
--- a/gcc/m2/gm2-libs-pim/Random.mod
+++ b/gcc/m2/gm2-libs-log/Random.mod
diff --git a/gcc/m2/gm2-libs-pim/RealConversions.def b/gcc/m2/gm2-libs-log/RealConversions.def
index 033cd3a..033cd3a 100644
--- a/gcc/m2/gm2-libs-pim/RealConversions.def
+++ b/gcc/m2/gm2-libs-log/RealConversions.def
diff --git a/gcc/m2/gm2-libs-pim/RealConversions.mod b/gcc/m2/gm2-libs-log/RealConversions.mod
index 189096a..189096a 100644
--- a/gcc/m2/gm2-libs-pim/RealConversions.mod
+++ b/gcc/m2/gm2-libs-log/RealConversions.mod
diff --git a/gcc/m2/gm2-libs-pim/RealInOut.def b/gcc/m2/gm2-libs-log/RealInOut.def
index 2c6a04b..2c6a04b 100644
--- a/gcc/m2/gm2-libs-pim/RealInOut.def
+++ b/gcc/m2/gm2-libs-log/RealInOut.def
diff --git a/gcc/m2/gm2-libs-pim/RealInOut.mod b/gcc/m2/gm2-libs-log/RealInOut.mod
index 855ab9b..855ab9b 100644
--- a/gcc/m2/gm2-libs-pim/RealInOut.mod
+++ b/gcc/m2/gm2-libs-log/RealInOut.mod
diff --git a/gcc/m2/gm2-libs-pim/Strings.def b/gcc/m2/gm2-libs-log/Strings.def
index 5f3f42c..5f3f42c 100644
--- a/gcc/m2/gm2-libs-pim/Strings.def
+++ b/gcc/m2/gm2-libs-log/Strings.def
diff --git a/gcc/m2/gm2-libs-pim/Strings.mod b/gcc/m2/gm2-libs-log/Strings.mod
index 99dc6c1..99dc6c1 100644
--- a/gcc/m2/gm2-libs-pim/Strings.mod
+++ b/gcc/m2/gm2-libs-log/Strings.mod
diff --git a/gcc/m2/gm2-libs-pim/Termbase.def b/gcc/m2/gm2-libs-log/Termbase.def
index 8adc5d0..8adc5d0 100644
--- a/gcc/m2/gm2-libs-pim/Termbase.def
+++ b/gcc/m2/gm2-libs-log/Termbase.def
diff --git a/gcc/m2/gm2-libs-pim/Termbase.mod b/gcc/m2/gm2-libs-log/Termbase.mod
index 0b47826..0b47826 100644
--- a/gcc/m2/gm2-libs-pim/Termbase.mod
+++ b/gcc/m2/gm2-libs-log/Termbase.mod
diff --git a/gcc/m2/gm2-libs-pim/Terminal.def b/gcc/m2/gm2-libs-log/Terminal.def
index a97e9fb..a97e9fb 100644
--- a/gcc/m2/gm2-libs-pim/Terminal.def
+++ b/gcc/m2/gm2-libs-log/Terminal.def
diff --git a/gcc/m2/gm2-libs-pim/Terminal.mod b/gcc/m2/gm2-libs-log/Terminal.mod
index cff1b5c..cff1b5c 100644
--- a/gcc/m2/gm2-libs-pim/Terminal.mod
+++ b/gcc/m2/gm2-libs-log/Terminal.mod
diff --git a/gcc/m2/gm2-libs-pim/TimeDate.def b/gcc/m2/gm2-libs-log/TimeDate.def
index d3f3e7d..d3f3e7d 100644
--- a/gcc/m2/gm2-libs-pim/TimeDate.def
+++ b/gcc/m2/gm2-libs-log/TimeDate.def
diff --git a/gcc/m2/gm2-libs-pim/TimeDate.mod b/gcc/m2/gm2-libs-log/TimeDate.mod
index 74644e8..74644e8 100644
--- a/gcc/m2/gm2-libs-pim/TimeDate.mod
+++ b/gcc/m2/gm2-libs-log/TimeDate.mod
diff --git a/gcc/m2/gm2-libs/Args.mod b/gcc/m2/gm2-libs/Args.mod
index 30f76c6..fa14f8c 100644
--- a/gcc/m2/gm2-libs/Args.mod
+++ b/gcc/m2/gm2-libs/Args.mod
@@ -62,7 +62,7 @@ BEGIN
    IF i < GetArgC ()
    THEN
       Source := GetArgV () ;
-      WHILE (Source^[i]^[j]#nul) AND (j<High) DO
+      WHILE (j<High) AND (Source^[i]^[j]#nul) DO
          a[j] := Source^[i]^[j] ;
          INC(j)
       END
diff --git a/gcc/m2/gm2-libs/DynamicStrings.mod b/gcc/m2/gm2-libs/DynamicStrings.mod
index 9839e43..a109e7a 100644
--- a/gcc/m2/gm2-libs/DynamicStrings.mod
+++ b/gcc/m2/gm2-libs/DynamicStrings.mod
@@ -1215,14 +1215,6 @@ BEGIN
          i := 0 ;
          Assert (a^.contents.len = b^.contents.len) ;
          WHILE i<a^.contents.len DO
-            IF a^.contents.buf[i] # a^.contents.buf[i]
-            THEN
-               HALT
-            END ;
-            IF b^.contents.buf[i] # b^.contents.buf[i]
-            THEN
-               HALT
-            END ;
             IF a^.contents.buf[i] # b^.contents.buf[i]
             THEN
                RETURN FALSE
diff --git a/gcc/m2/gm2-libs/M2Dependent.mod b/gcc/m2/gm2-libs/M2Dependent.mod
index 72675eb..f343ac3 100644
--- a/gcc/m2/gm2-libs/M2Dependent.mod
+++ b/gcc/m2/gm2-libs/M2Dependent.mod
@@ -203,7 +203,7 @@ BEGIN
    i := 0 ;
    high := HIGH (str) ;
    WHILE i < high DO
-      IF (str[i] = "\") AND (i < high)
+      IF (i < high) AND (str[i] = "\")
       THEN
          IF str[i+1] = "n"
          THEN
diff --git a/gcc/m2/gm2-libs/M2RTS.def b/gcc/m2/gm2-libs/M2RTS.def
index 94ed2d0..b551725 100644
--- a/gcc/m2/gm2-libs/M2RTS.def
+++ b/gcc/m2/gm2-libs/M2RTS.def
@@ -120,12 +120,23 @@ PROCEDURE HALT ([exitcode: INTEGER = -1]) <* noreturn *> ;
 
 (*
    Halt - provides a more user friendly version of HALT, which takes
-          four parameters to aid debugging.
+           four parameters to aid debugging.  It writes an error message
+           to stderr and calls exit (1).
 *)
 
-PROCEDURE Halt (file: ARRAY OF CHAR; line: CARDINAL;
+PROCEDURE Halt (filename: ARRAY OF CHAR; line: CARDINAL;
                 function: ARRAY OF CHAR; description: ARRAY OF CHAR)
-		<* noreturn *> ;
+	 	<* noreturn *> ;
+
+
+(*
+   HaltC - provides a more user friendly version of HALT, which takes
+           four parameters to aid debugging.  It writes an error message
+           to stderr and calls exit (1).
+*)
+
+PROCEDURE HaltC (filename: ADDRESS; line: CARDINAL;
+                 function, description: ADDRESS) ;
 
 
 (*
@@ -140,7 +151,7 @@ PROCEDURE ExitOnHalt (e: INTEGER) ;
 *)
 
 PROCEDURE ErrorMessage (message: ARRAY OF CHAR;
-                        file: ARRAY OF CHAR;
+                        filename: ARRAY OF CHAR;
                         line: CARDINAL;
                         function: ARRAY OF CHAR) <* noreturn *> ;
 
diff --git a/gcc/m2/gm2-libs/M2RTS.mod b/gcc/m2/gm2-libs/M2RTS.mod
index 0534c5d..4280fec 100644
--- a/gcc/m2/gm2-libs/M2RTS.mod
+++ b/gcc/m2/gm2-libs/M2RTS.mod
@@ -27,7 +27,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 IMPLEMENTATION MODULE M2RTS ;
 
 
-FROM libc IMPORT abort, exit, write, getenv, printf ;
+FROM libc IMPORT abort, exit, write, getenv, printf, strlen ;
 (* FROM Builtins IMPORT strncmp, strcmp ;  not available during bootstrap.  *)
 FROM NumberIO IMPORT CardToStr ;
 FROM StrLib IMPORT StrCopy, StrLen, StrEqual ;
@@ -39,6 +39,9 @@ IMPORT RTExceptions ;
 IMPORT M2EXCEPTION ;
 IMPORT M2Dependent ;
 
+CONST
+   stderrFd = 2 ;
+
 TYPE
    PtrToChar = POINTER TO CHAR ;
 
@@ -254,24 +257,36 @@ PROCEDURE ErrorString (a: ARRAY OF CHAR) ;
 VAR
    n: INTEGER ;
 BEGIN
-   n := write (2, ADR (a), StrLen (a))
+   n := write (stderrFd, ADR (a), StrLen (a))
 END ErrorString ;
 
 
 (*
+   ErrorStringC - writes a string to stderr.
+*)
+
+PROCEDURE ErrorStringC (str: ADDRESS) ;
+VAR
+   len: INTEGER ;
+BEGIN
+   len := write (stderrFd, str, strlen (str))
+END ErrorStringC ;
+
+
+(*
    ErrorMessage - emits an error message to stderr and then calls exit (1).
 *)
 
 PROCEDURE ErrorMessage (message: ARRAY OF CHAR;
-                        file: ARRAY OF CHAR;
+                        filename: ARRAY OF CHAR;
                         line: CARDINAL;
                         function: ARRAY OF CHAR) <* noreturn *> ;
 VAR
-   LineNo: ARRAY [0..10] OF CHAR ;
+   buffer: ARRAY [0..10] OF CHAR ;
 BEGIN
-   ErrorString (file) ; ErrorString(':') ;
-   CardToStr (line, 0, LineNo) ;
-   ErrorString (LineNo) ; ErrorString(':') ;
+   ErrorString (filename) ; ErrorString(':') ;
+   CardToStr (line, 0, buffer) ;
+   ErrorString (buffer) ; ErrorString(':') ;
    IF NOT StrEqual (function, '')
    THEN
       ErrorString ('in ') ;
@@ -279,22 +294,61 @@ BEGIN
       ErrorString (' has caused ') ;
    END ;
    ErrorString (message) ;
-   LineNo[0] := nl ; LineNo[1] := nul ;
-   ErrorString (LineNo) ;
+   buffer[0] := nl ; buffer[1] := nul ;
+   ErrorString (buffer) ;
    exit (1)
 END ErrorMessage ;
 
 
 (*
+   ErrorMessageC - emits an error message to stderr and then calls exit (1).
+*)
+
+PROCEDURE ErrorMessageC (message, filename: ADDRESS;
+                         line: CARDINAL;
+                         function: ADDRESS) <* noreturn *> ;
+VAR
+   buffer: ARRAY [0..10] OF CHAR ;
+BEGIN
+   ErrorStringC (filename) ; ErrorString (':') ;
+   CardToStr (line, 0, buffer) ;
+   ErrorString (buffer) ; ErrorString(':') ;
+   IF strlen (function) > 0
+   THEN
+      ErrorString ('in ') ;
+      ErrorStringC (function) ;
+      ErrorString (' has caused ') ;
+   END ;
+   ErrorStringC (message) ;
+   buffer[0] := nl ; buffer[1] := nul ;
+   ErrorString (buffer) ;
+   exit (1)
+END ErrorMessageC ;
+
+
+(*
+   HaltC - provides a more user friendly version of HALT, which takes
+           four parameters to aid debugging.  It writes an error message
+           to stderr and calls exit (1).
+*)
+
+PROCEDURE HaltC (filename: ADDRESS; line: CARDINAL;
+                 function, description: ADDRESS) ;
+BEGIN
+   ErrorMessageC (description, filename, line, function)
+END HaltC ;
+
+
+(*
    Halt - provides a more user friendly version of HALT, which takes
-          four parameters to aid debugging.
+          four parameters to aid debugging.  It writes an error message
+          to stderr and calls exit (1).
 *)
 
-PROCEDURE Halt (file: ARRAY OF CHAR; line: CARDINAL;
+PROCEDURE Halt (filename: ARRAY OF CHAR; line: CARDINAL;
                 function: ARRAY OF CHAR; description: ARRAY OF CHAR) ;
 BEGIN
-   ErrorMessage (description, file, line, function) ;
-   HALT
+   ErrorMessage (description, filename, line, function)
 END Halt ;
 
 
diff --git a/gcc/m2/gm2-libs/config-host b/gcc/m2/gm2-libs/config-host
index 184c363..5d6d33d 100755
--- a/gcc/m2/gm2-libs/config-host
+++ b/gcc/m2/gm2-libs/config-host
@@ -5,7 +5,7 @@
 # Report bugs to <gm2@nongnu.org>.
 #
 #
-# Copyright (C) 1992-2023 Free Software Foundation, Inc.
+# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
 #
 #
 # This configure script is free software; the Free Software Foundation
@@ -1369,7 +1369,7 @@ if $ac_init_version; then
 ASCII.def configure 1.9.5
 generated by GNU Autoconf 2.69
 
-Copyright (C) 2012-2023 Free Software Foundation, Inc.
+Copyright (C) 2012 Free Software Foundation, Inc.
 This configure script is free software; the Free Software Foundation
 gives unlimited permission to copy, distribute and modify it.
 _ACEOF
@@ -5298,7 +5298,7 @@ ASCII.def config.status 1.9.5
 configured by $0, generated by GNU Autoconf 2.69,
   with options \\"\$ac_cs_config\\"
 
-Copyright (C) 2012-2023 Free Software Foundation, Inc.
+Copyright (C) 2012 Free Software Foundation, Inc.
 This config.status script is free software; the Free Software Foundation
 gives unlimited permission to copy, distribute and modify it."
 
diff --git a/gcc/m2/gm2config.h.in b/gcc/m2/gm2config.aci.in
index fe2f814..cb9f505 100644
--- a/gcc/m2/gm2config.h.in
+++ b/gcc/m2/gm2config.aci.in
@@ -1,4 +1,4 @@
-/* gm2config.h.in.  Generated from configure.ac by autoheader.  */
+/* gm2config.aci.in.  Generated from configure.ac by autoheader.  */
 
 /* Define to 1 if you have the <dirent.h> header file, and it defines `DIR'.
    */
diff --git a/gcc/m2/gm2spec.cc b/gcc/m2/gm2spec.cc
index f964ecc..bc93133 100644
--- a/gcc/m2/gm2spec.cc
+++ b/gcc/m2/gm2spec.cc
@@ -103,6 +103,7 @@ enum stdcxxlib_kind
 };
 
 #define DEFAULT_DIALECT "pim"
+
 #undef DEBUG_ARG
 
 typedef enum { iso, pim, min, logitech, pimcoroutine, maxlib } libs;
@@ -132,14 +133,15 @@ static const char *add_include (const char *libpath, const char *library);
 
 static bool seen_scaffold_static = false;
 static bool seen_scaffold_dynamic = false;
+static bool seen_scaffold_main = false;
 static bool scaffold_static = false;
-static bool scaffold_dynamic = true;  // Default uses -fscaffold-dynamic.
+static bool scaffold_dynamic = true; // Default uses -fscaffold-dynamic.
+static bool scaffold_main = false;
 static bool seen_gen_module_list = false;
 static bool seen_uselist = false;
 static bool uselist = false;
 static bool gen_module_list = true;  // Default uses -fgen-module-list=-.
 static const char *gen_module_filename = "-";
-static const char *multilib_dir = NULL;
 /* The original argument list and related info is copied here.  */
 static unsigned int gm2_xargc;
 static const struct cl_decoded_option *gm2_x_decoded_options;
@@ -148,6 +150,8 @@ static void append_arg (const struct cl_decoded_option *);
 /* The new argument list will be built here.  */
 static unsigned int gm2_newargc;
 static struct cl_decoded_option *gm2_new_decoded_options;
+static const char *full_libraries = NULL;
+static const char *libraries = NULL;  /* Abbreviated libraries.  */
 
 
 /* Return whether strings S1 and S2 are both NULL or both the same
@@ -227,50 +231,6 @@ append_option (size_t opt_index, const char *arg, int value)
   append_arg (&decoded);
 }
 
-/* build_archive_path returns a string containing the path to the
-   archive defined by libpath and dialectLib.  */
-
-static const char *
-build_archive_path (const char *libpath, const char *library)
-{
-  if (library != NULL)
-    {
-      const char *libdir = (const char *)library;
-
-      if (libdir != NULL)
-        {
-	  int machine_length = 0;
-          char dir_sep[2];
-
-          dir_sep[0] = DIR_SEPARATOR;
-          dir_sep[1] = (char)0;
-
-	  if (multilib_dir != NULL)
-	    {
-	      machine_length = strlen (multilib_dir);
-	      machine_length += strlen (dir_sep);
-	    }
-
-	  int l = strlen (libpath) + 1 + strlen ("m2") + 1
-	    + strlen (libdir) + 1 + machine_length + 1;
-          char *s = (char *)xmalloc (l);
-
-          strcpy (s, libpath);
-          strcat (s, dir_sep);
-	  if (machine_length > 0)
-	    {
-	      strcat (s, multilib_dir);
-	      strcat (s, dir_sep);
-	    }
-          strcat (s, "m2");
-          strcat (s, dir_sep);
-          strcat (s, libdir);
-          return s;
-        }
-    }
-  return NULL;
-}
-
 /* safe_strdup safely duplicates a string.  */
 
 static char *
@@ -281,205 +241,65 @@ safe_strdup (const char *s)
   return NULL;
 }
 
-/* add_default_combination adds the correct link path and then the
-   library name.  */
-
-static bool
-add_default_combination (const char *libpath, const char *library)
+static char *
+concat_option (char *dest, const char *pre, const char *path, const char *post)
 {
-  if (library != NULL)
+  if (dest == NULL)
+    {
+      dest = (char *) xmalloc (strlen (pre) + strlen (path) + strlen (post) + 1);
+      strcpy (dest, pre);
+      strcat (dest, path);
+      strcat (dest, post);
+      return dest;
+    }
+  else
     {
-      append_option (OPT_L, build_archive_path (libpath, library), 1);
-      append_option (OPT_l, safe_strdup (library), 1);
-      return true;
+      char *result = (char *) xmalloc (strlen (dest) + strlen (pre)
+				       + strlen (path) + strlen (post) + 1 + 1);
+      strcpy (result, dest);
+      strcat (result, " ");
+      strcat (result, pre);
+      strcat (result, path);
+      strcat (result, post);
+      free (dest);
+      return result;
     }
-  return false;
 }
 
-/* add_default_archives adds the default archives to the end of the
-   current command line.  */
+/* add_default_libs adds the -l option which is derived from the
+   libraries.  */
 
 static int
-add_default_archives (const char *libpath, const char *libraries)
+add_default_libs (const char *libraries)
 {
   const char *l = libraries;
   const char *e;
   char *libname;
   unsigned int libcount = 0;
 
-  do
+  while ((l != NULL) && (l[0] != (char)0))
     {
       e = index (l, ',');
       if (e == NULL)
         {
           libname = xstrdup (l);
           l = NULL;
-	  if (add_default_combination (libpath, libname))
-	    libcount++;
+	  append_option (OPT_l, safe_strdup (libname), 1);
+	  libcount++;
 	  free (libname);
         }
       else
         {
           libname = xstrndup (l, e - l);
           l = e + 1;
-	  if (add_default_combination (libpath, libname))
-	    libcount++;
+	  append_option (OPT_l, safe_strdup (libname), 1);
+	  libcount++;
 	  free (libname);
         }
     }
-  while ((l != NULL) && (l[0] != (char)0));
   return libcount;
 }
 
-/* build_include_path builds the component of the include path
-   referenced by the library.  */
-
-static const char *
-build_include_path (const char *libpath, const char *library)
-{
-  char dir_sep[2];
-  char *gm2libs;
-  unsigned int machine_length = 0;
-
-  dir_sep[0] = DIR_SEPARATOR;
-  dir_sep[1] = (char)0;
-
-  if (multilib_dir != NULL)
-    {
-      machine_length = strlen (multilib_dir);
-      machine_length += strlen (dir_sep);
-    }
-
-  gm2libs = (char *)alloca (strlen (libpath) + strlen (dir_sep) + strlen ("m2")
-                            + strlen (dir_sep) + strlen (library) + 1
-			    + machine_length + 1);
-  strcpy (gm2libs, libpath);
-  strcat (gm2libs, dir_sep);
-  if (machine_length > 0)
-    {
-      strcat (gm2libs, multilib_dir);
-      strcat (gm2libs, dir_sep);
-    }
-  strcat (gm2libs, "m2");
-  strcat (gm2libs, dir_sep);
-  strcat (gm2libs, library);
-
-  return xstrdup (gm2libs);
-}
-
-/* add_include add the correct include path given the libpath and
-   library.  The new path is returned.  */
-
-static const char *
-add_include (const char *libpath, const char *library)
-{
-  if (library == NULL)
-    return NULL;
-  else
-    return build_include_path (libpath, library);
-}
-
-/* add_default_includes add the appropriate default include paths
-   depending upon the style of libraries chosen.  */
-
-static void
-add_default_includes (const char *libpath, const char *libraries)
-{
-  const char *l = libraries;
-  const char *e;
-  const char *c;
-  const char *path;
-
-  do
-    {
-      e = index (l, ',');
-      if (e == NULL)
-        {
-          c = xstrdup (l);
-          l = NULL;
-        }
-      else
-        {
-          c = xstrndup (l, e - l);
-          l = e + 1;
-        }
-      path = add_include (libpath, c);
-      append_option (OPT_I, path, 1);
-    }
-  while ((l != NULL) && (l[0] != (char)0));
-}
-
-/* library_installed returns true if directory library is found under
-   libpath.  */
-
-static bool
-library_installed (const char *libpath, const char *library)
-{
-#if defined(HAVE_OPENDIR) && defined(HAVE_DIRENT_H)
-  const char *complete = build_archive_path (libpath, library);
-  DIR *directory = opendir (complete);
-
-  if (directory == NULL || (errno == ENOENT))
-    return false;
-  /* Directory exists and therefore the library also exists.  */
-  closedir (directory);
-  return true;
-#else
-  return false;
-#endif
-}
-
-/* check_valid check to see that the library is valid.
-   It check the library against the default library set in gm2 and
-   also against any additional libraries installed in the prefix tree.  */
-
-static bool
-check_valid_library (const char *libpath, const char *library)
-{
-  /* Firstly check against the default libraries (which might not be
-     installed yet).  */
-  for (int i = 0; i < maxlib; i++)
-    if (strcmp (library, library_name[i]) == 0)
-      return true;
-  /* Secondly check whether it is installed (a third party library).  */
-  return library_installed (libpath, library);
-}
-
-/* check_valid_list check to see that the libraries specified are valid.
-   It checks against the default library set in gm2 and also against
-   any additional libraries installed in the libpath tree.  */
-
-static bool
-check_valid_list (const char *libpath, const char *libraries)
-{
-  const char *start = libraries;
-  const char *end;
-  const char *copy;
-
-  do
-    {
-      end = index (start, ',');
-      if (end == NULL)
-        {
-          copy = xstrdup (start);
-          start = NULL;
-        }
-      else
-        {
-          copy = xstrndup (start, end - start);
-          start = end + 1;
-        }
-      if (! check_valid_library (libpath, copy))
-	{
-	  error ("library specified %sq is either not installed or does not exist",
-		 copy);
-	  return false;
-	}
-    }
-  while ((start != NULL) && (start[0] != (char)0));
-  return true;
-}
-
 /* add_word returns a new string which has the contents of lib
    appended to list.  If list is NULL then lib is duplicated and
    returned otherwise the list is appended by "," and the contents of
@@ -509,8 +329,14 @@ convert_abbreviation (const char *full_libraries, const char *abbreviation)
   for (int i = 0; i < maxlib; i++)
     if (strcmp (abbreviation, library_abbrev[i]) == 0)
       return add_word (full_libraries, library_name[i]);
-  /* No abbreviation found therefore assume user specified full library name.  */
-  return add_word (full_libraries, abbreviation);
+  /* Perhaps the user typed in the whole lib name rather than an abbrev.  */
+  for (int i = 0; i < maxlib; i++)
+    if (strcmp (abbreviation, library_name[i]) == 0)
+      return add_word (full_libraries, abbreviation);
+  /* Not found, probably a user typo.  */
+  error ("%qs is not a valid Modula-2 system library name or abbreviation",
+	 abbreviation);
+  return full_libraries;
 }
 
 /* convert_abbreviations checks each element in the library list to
@@ -535,7 +361,8 @@ convert_abbreviations (const char *libraries)
         }
       else
         {
-          full_libraries = convert_abbreviation (full_libraries, xstrndup (start, end - start));
+	  full_libraries = convert_abbreviation (full_libraries,
+						 xstrndup (start, end - start));
           start = end + 1;
         }
     }
@@ -572,9 +399,7 @@ lang_specific_driver (struct cl_decoded_option **in_decoded_options,
   /* Which c++ runtime library to link.  */
   stdcxxlib_kind which_library = USE_LIBSTDCXX;
 
-  const char *libraries = NULL;
   const char *dialect = DEFAULT_DIALECT;
-  const char *libpath = LIBSUBDIR;
 
   /* An array used to flag each argument that needs a bit set for
      LANGSPEC, MATHLIB, or WITHLIBC.  */
@@ -673,12 +498,15 @@ lang_specific_driver (struct cl_decoded_option **in_decoded_options,
 	case OPT_flibs_:
 	  libraries = xstrdup (arg);
 	  allow_libraries = decoded_options[i].value;
+	  args[i] |= SKIPOPT; /* We will add the option if it is needed.  */
 	  break;
 	case OPT_fmod_:
 	  seen_module_extension = true;
+	  args[i] |= SKIPOPT; /* We will add the option if it is needed.  */
 	  break;
         case OPT_fpthread:
           need_pthread = decoded_options[i].value;
+	  args[i] |= SKIPOPT; /* We will add the option if it is needed.  */
           break;
         case OPT_fm2_plugin:
           need_plugin = decoded_options[i].value;
@@ -687,14 +515,22 @@ lang_specific_driver (struct cl_decoded_option **in_decoded_options,
 	    error ("plugin support is disabled; configure with "
 		   "%<--enable-plugin%>");
 #endif
+	  args[i] |= SKIPOPT; /* We will add the option if it is needed.  */
           break;
 	case OPT_fscaffold_dynamic:
 	  seen_scaffold_dynamic = true;
 	  scaffold_dynamic = decoded_options[i].value;
+	  args[i] |= SKIPOPT; /* We will add the option if it is needed.  */
 	  break;
 	case OPT_fscaffold_static:
 	  seen_scaffold_static = true;
 	  scaffold_static = decoded_options[i].value;
+	  args[i] |= SKIPOPT; /* We will add the option if it is needed.  */
+	  break;
+	case OPT_fscaffold_main:
+	  seen_scaffold_main = true;
+	  scaffold_main = decoded_options[i].value;
+	  args[i] |= SKIPOPT; /* We will add the option if it is needed.  */
 	  break;
 	case OPT_fgen_module_list_:
 	  seen_gen_module_list = true;
@@ -761,6 +597,14 @@ lang_specific_driver (struct cl_decoded_option **in_decoded_options,
 	  library = -1;
 	  break;
 
+	/* PCH makes no sense here, we do not catch -output-pch on purpose,
+	   that should flag an error.  */
+	case OPT_fpch_deps:
+	case OPT_fpch_preprocess:
+	case OPT_Winvalid_pch:
+	  args[i] |= SKIPOPT;
+	  break;
+
 	case OPT_static:
 	  static_link = 1;
 	  break;
@@ -794,24 +638,23 @@ lang_specific_driver (struct cl_decoded_option **in_decoded_options,
 	  break;
 
 	default:
-	  if ((decoded_options[i].orig_option_with_args_text != NULL)
-	      && (strncmp (decoded_options[i].orig_option_with_args_text,
-			   "-m", 2) == 0))
-	    multilib_dir = xstrdup (decoded_options[i].orig_option_with_args_text
-				    + 2);
+	  break;
 	}
     }
   if (language != NULL && (strcmp (language, "modula-2") != 0))
     return;
 
-  if (scaffold_static && scaffold_dynamic)
-    {
-      if (! seen_scaffold_dynamic)
-	scaffold_dynamic = false;
-      if (scaffold_dynamic && scaffold_static)
-	error ("%qs and %qs cannot both be enabled",
-	       "-fscaffold-dynamic", "-fscaffold-static");
-    }
+  /* Override the default when the user specifies it.  */
+  if (seen_scaffold_static && scaffold_static && !seen_scaffold_dynamic)
+    scaffold_dynamic = false;
+
+  /* If both options have been seen and both are true, that means the user
+     tried to set both.  */
+  if (seen_scaffold_dynamic && scaffold_dynamic
+     && seen_scaffold_static && scaffold_static)
+    error ("%qs and %qs cannot both be enabled",
+	   "-fscaffold-dynamic", "-fscaffold-static");
+
   if (uselist && gen_module_list)
     {
       if (! seen_gen_module_list)
@@ -855,32 +698,54 @@ lang_specific_driver (struct cl_decoded_option **in_decoded_options,
 #endif
     }
 
-  /* We now add in extra arguments to facilitate a successful
-     compile or link.  For example include paths for dialect of Modula-2,
-     library paths and default scaffold linking options.  */
+  /* We now add in extra arguments to facilitate a successful link.
+     Note that the libraries are added to the end of the link here
+     and also placed earlier into the link by lang-specs.h.  Possibly
+     this is needed because the m2pim,m2iso libraries are cross linked
+     (--fixme-- combine all the m2 libraries into a single archive).
+
+     We also add default scaffold linking options.  */
 
   /* If we have not seen either uselist or gen_module_list and we need
-     to link then we turn on -fgen_module_list=- as the default.  */
-  if ((! (seen_uselist || seen_gen_module_list)) && linking)
+     to link or compile a module list then we turn on -fgen_module_list=-
+     as the default.  */
+  if (!seen_uselist && !seen_gen_module_list
+      && (linking || scaffold_main))
     append_option (OPT_fgen_module_list_, "-", 1);
 
+  /* We checked that they were not both enabled above, if there was a set
+     value (even iff that is 'off'), pass that to the FE.  */
+  if (seen_scaffold_dynamic || scaffold_dynamic)
+    append_option (OPT_fscaffold_dynamic, NULL, scaffold_dynamic);
+  if (seen_scaffold_static)
+    append_option (OPT_fscaffold_static, NULL, scaffold_static);
+
+  /* If the user has set fscaffold-main specifically, use that.  Otherwise, if
+     we are linking then set it so that we generate the relevant code for the
+     main module.  */
+  if (seen_scaffold_main)
+    append_option (OPT_fscaffold_main, NULL, scaffold_main);
+  else if (linking)
+    append_option (OPT_fscaffold_main, NULL, true);
+
   if (allow_libraries)
     {
-      /* If the libraries have not been specified by the user but the
-	 dialect has been specified then select the appropriate libraries.  */
+      /* If the libraries have not been specified by the user, select the
+	 appropriate libraries for the active dialect.  */
       if (libraries == NULL)
 	{
 	  if (strcmp (dialect, "iso") == 0)
-	    libraries = xstrdup ("m2iso,m2pim");
+	    libraries = xstrdup ("m2iso,m2cor,m2pim,m2log");
 	  else
-	    /* Default to pim libraries if none specified.  */
-	    libraries = xstrdup ("m2pim,m2log,m2iso");
+	    /* Default to pim libraries otherwise.  */
+	    libraries = xstrdup ("m2pim,m2iso,m2cor,m2log");
 	}
       libraries = convert_abbreviations (libraries);
-      if (! check_valid_list (libpath, libraries))
-	return;
-      add_default_includes (libpath, libraries);
+      append_option (OPT_flibs_, xstrdup (libraries), 1);
     }
+  else
+    append_option (OPT_flibs_, xstrdup ("-"), 0); /* no system libs.  */
+
   if ((! seen_x_flag) && seen_module_extension)
     append_option (OPT_x, "modula-2", 1);
 
@@ -889,16 +754,19 @@ lang_specific_driver (struct cl_decoded_option **in_decoded_options,
 
   if (linking)
     {
+      if (allow_libraries)
+	{
 #ifdef HAVE_LD_STATIC_DYNAMIC
-      if (allow_libraries && !shared_libgm2)
-	append_option (OPT_Wl_, LD_STATIC_OPTION, 1);
+	  if (!shared_libgm2)
+	    append_option (OPT_Wl_, LD_STATIC_OPTION, 1);
 #endif
-      if (allow_libraries)
-	add_default_archives (libpath, libraries);
+	  added_libraries += add_default_libs (libraries);
 #ifdef HAVE_LD_STATIC_DYNAMIC
-      if (allow_libraries && !shared_libgm2)
-	append_option (OPT_Wl_, LD_DYNAMIC_OPTION, 1);
+	  if (!shared_libgm2)
+	    append_option (OPT_Wl_, LD_DYNAMIC_OPTION, 1);
 #endif
+	}
+
       /* Add `-lstdc++' if we haven't already done so.  */
 #ifdef HAVE_LD_STATIC_DYNAMIC
       if (library > 1 && !static_link)
@@ -962,6 +830,7 @@ lang_specific_driver (struct cl_decoded_option **in_decoded_options,
   *in_added_libraries = added_libraries;
 }
 
+
 /* Called before linking.  Returns 0 on success and -1 on failure.  */
 int
 lang_specific_pre_link (void)  /* Not used for M2.  */
diff --git a/gcc/m2/lang-specs.h b/gcc/m2/lang-specs.h
index 92dc20f..65004e1 100644
--- a/gcc/m2/lang-specs.h
+++ b/gcc/m2/lang-specs.h
@@ -21,18 +21,36 @@ along with GCC; see the file COPYING3.  If not see
 /* This is the contribution to the `default_compilers' array in gcc.c for
    GNU Modula-2.  */
 
-/* Pass the preprocessor options on the command line together with
-   the exec prefix.  */
-
-#define M2CPP "%{fcpp:-fcpp-begin " \
-              "      -E -lang-asm -traditional-cpp " \
-              "      %(cpp_unique_options) -fcpp-end}"
+/* A spec for the 'integrated' preprocessor implementation for Modula-2.  */
+#define M2CPP \
+  "%{E|M|MM|fcpp: %{E} -fcpp-begin " \
+  "      %{!E:-E} %(cpp_unique_options) -traditional-cpp -ansi " \
+  "      -fcpp-end %{B*} %{save-temps*} ; \
+     : %{v} %I %{B*} %{save-temps*} } "
+
+/* We have three modes:
+   1. When the preprocessing step is explict and there is no following
+      compilation.  Here we do a similar process to cc1 -E where most of
+      the compilation is short-circuited.
+   2. When we are mimicking an integrated preprocessor.  Here we use the
+      modula-2 'fcpp' to construct a command line for the preprocessor and
+      snarf save-temps and dumpdir inputs to try and be consistent.
+   3. We can consume a pre-processed modula-2 source.  */
 
   {".mod", "@modula-2", 0, 0, 0},
   {"@modula-2",
-      "cc1gm2 " M2CPP
-      "      %(cc1_options) %{B*} %{c*} %{f*} %{+e*} %{I*} "
-      "      %{MD} %{MMD} %{M} %{MM} %{MA} %{MT*} %{MF*} %V"
-      "      %{save-temps*} %{v} "
-      "      %i %{!fsyntax-only:%(invoke_as)}",
-      0, 0, 0},
+   /* For preprocessing we use cc1 but wrap it in cc1gm2.  */
+   "%{E|M|MM:\
+      cc1gm2 " M2CPP " %{!fcpp:-fcpp;:%{fcpp}} %{I*} %i } \
+    %{!E:%{!M:%{!MM:\
+      cc1gm2 " M2CPP " %(cc1_options) %{I*} %i %{c} \
+      %{!fcpp:%{MD|MMD|MF*: \
+		%eto generate dependencies you must specify '-fcpp' }} \
+      %{!fsyntax-only:%(invoke_as)} \
+    }}}", 0, 0, 0},
+  {".m2i", "@modula-2-cpp-output", 0, 0, 0},
+  {"@modula-2-cpp-output",
+   "%{!M:%{!MM:%{!E: \
+      cc1gm2 %<fcpp %(cc1_options) %{v} %I -fmod=.mod.m2i -fdef=.def.m2i %{I*} \
+	-fpreprocessed %i %{c} \
+    %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 0},
diff --git a/gcc/m2/lang.opt b/gcc/m2/lang.opt
index 6586fd6..b6ef816 100644
--- a/gcc/m2/lang.opt
+++ b/gcc/m2/lang.opt
@@ -21,47 +21,15 @@
 
 ; See the GCC internals manual for a description of this file's format.
 
+; There are two sections:
+;  1. Options specific to Modula-2
+;  2. Options shared with C or the Driver.
+; Please keep any new additions for either case in the relevant section.
 ; Please try to keep this file in ASCII collating order.
 
 Language
 Modula-2
 
-B
-Modula-2
-; Documented in c.opt
-
-D
-Modula-2
-; Documented in c.opt
-
-E
-Modula-2
-; Documented in c.opt (passed to the preprocessor if -fcpp is used)
-
-I
-Modula-2 Joined Separate
-; Documented in c.opt
-
-L
-Modula-2 Joined Separate
-; Not documented
-
-M
-Modula-2
-; Documented in c.opt
-
-O
-Modula-2
-; Documented in c.opt
-
-Wall
-Modula-2
-; Documented in c.opt
-
-Wpedantic
-Modula-2
-; Documented in common.opt
-
 Wpedantic-param-names
 Modula-2
 compiler checks to force definition module procedure parameter names with their implementation module counterpart
@@ -78,18 +46,6 @@ Wstyle
 Modula-2
 extra compile time semantic checking, typically tries to catch poor programming style
 
-Wunused-variable
-Modula-2
-; Documented in c.opt
-
-Wunused-parameter
-Modula-2
-; Documented in c.opt
-
-c
-Modula-2
-; Documented in c.opt
-
 fauto-init
 Modula-2
 automatically initializes all pointers to NIL
@@ -102,10 +58,6 @@ fcase
 Modula-2
 turns on runtime checking to check whether a CASE statement requires an ELSE clause when on was not specified
 
-fobjc-std=objc1
-Modula-2
-; Documented in c.opt
-
 fcpp
 Modula-2
 use cpp to preprocess the module
@@ -146,10 +98,6 @@ fdump-system-exports
 Modula-2
 display all inbuilt system items
 
-fexceptions
-Modula-2
-; Documented in common.opt
-
 fextended-opaque
 Modula-2
 allows opaque types to be implemented as any type (a GNU Modula-2 extension)
@@ -306,26 +254,144 @@ fwholevalue
 Modula-2
 turns on runtime checking to check whether a whole number is about to exceed range
 
-iprefix
+static-libgm2
+Driver
+Link the standard Modula-2 libraries statically in the compilation.
+
+; Here are C options that we also recognise, either within the compiler
+; or to build the preprocessor command lines.
+
+Wall
 Modula-2
 ; Documented in c.opt
 
-isystem
+Wpedantic
+Modula-2
+; Documented in common.opt
+
+Wreturn-type
+Modula-2
+; Documented in common.opt
+
+Wunused-variable
 Modula-2
 ; Documented in c.opt
 
-idirafter
+Wunused-parameter
 Modula-2
 ; Documented in c.opt
 
-imultilib
+B
+Modula-2
+; Documented in c.opt
+
+D
+Modula-2
+; Documented in c.opt
+
+E
+Modula-2
+; Documented in c.opt
+
+I
+Modula-2 Joined Separate
+; Documented in c.opt
+
+L
+Modula-2 Joined Separate
+; Not documented
+
+M
+Modula-2
+; Documented in c.opt
+
+MD
+Modula-2
+; Documented in c.opt
+
+MF
+Modula-2
+; Documented in c.opt
+
+MG
+Modula-2
+; Documented in c.opt
+
+MM
+Modula-2
+; Documented in c.opt
+
+MMD
+Modula-2
+; Documented in c.opt
+
+Mmodules
+Modula-2
+; Documented in c.opt
+
+Mno-modules
+Modula-2
+; Documented in c.opt
+
+MP
+Modula-2
+; Documented in c.opt
+
+MQ
+Modula-2
+; Documented in c.opt
+
+MT
+Modula-2
+; Documented in c.opt
+
+P
+Modula-2
+; Documented in c.opt
+
+ansi
+Modula-2
+; Documented in c.opt
+
+c
+Modula-2
+; Documented in c.opt
+
+fexceptions
+Modula-2
+; Documented in common.opt
+
+fobjc-std=objc1
+Modula-2
+; Documented in c.opt
+
+fpreprocessed
 Modula-2
 ; Documented in c.opt
 
-lang-asm
+fworking-directory
 Modula-2
 ; Documented in c.opt
 
+iprefix
+Modula-2
+; Documented in c.opt
+
+iquote
+Modula-2
+; Documented in c.opt
+
+isystem
+Modula-2
+; Documented in c.opt
+
+idirafter
+Modula-2
+; Documented in c.opt
+
+imultilib
+Modula-2
+
 -save-temps
 Modula-2 Alias(save-temps)
 
@@ -341,16 +407,4 @@ traditional-cpp
 Modula-2
 ; Documented in c.opt
 
-v
-Modula-2
-; Documented in c.opt
-
-x
-Modula-2 Joined
-specify the language from the compiler driver
-
-static-libgm2
-Driver
-Link the standard Modula-2 libraries statically in the compilation.
-
 ; This comment is to ensure we retain the blank line above.
diff --git a/gcc/m2/m2.flex b/gcc/m2/m2.flex
index b537e65..2937290 100644
--- a/gcc/m2/m2.flex
+++ b/gcc/m2/m2.flex
@@ -27,6 +27,7 @@ along with GNU Modula-2; see the file COPYING3.  If not see
 #include "input.h"
 #include "m2options.h"
 
+static int cpreprocessor = 0;  /* Replace this with correct getter.  */
 
 #if defined(GM2USEGGC)
 #  include "ggc.h"
@@ -70,6 +71,7 @@ along with GNU Modula-2; see the file COPYING3.  If not see
   static int                  lineno      =1;   /* a running count of the file line number */
   static char                *filename    =NULL;
   static int                  commentLevel=0;
+  static int                  commentCLevel=0;
   static struct lineInfo     *currentLine=NULL;
   static struct functionInfo *currentFunction=NULL;
   static int                  seenFunctionStart=FALSE;
@@ -87,6 +89,8 @@ static  void updatepos                (void);
 static  void skippos                  (void);
 static  void poperrorskip             (const char *);
 static  void endOfComment             (void);
+static  void endOfCComment            (void);
+static  void splitSlashStar           (void);
 static  void handleDate               (void);
 static  void handleLine               (void);
 static  void handleFile               (void);
@@ -117,7 +121,7 @@ extern  void  yylex                   (void);
 %}
 
 %option nounput
-%x COMMENT COMMENT1 LINE0 LINE1 LINE2
+%x COMMENT COMMENT1 COMMENTC LINE0 LINE1 LINE2
 
 %%
 
@@ -131,8 +135,9 @@ extern  void  yylex                   (void);
                                pushLine();
                                skippos();
                                BEGIN COMMENT1;
-                             } else
+                             } else {
                                updatepos(); skippos();
+			     }
                            }
 <COMMENT>\n.*              { consumeLine(); }
 <COMMENT>.                 { updatepos(); skippos(); }
@@ -144,6 +149,24 @@ extern  void  yylex                   (void);
 <COMMENT1><<EOF>>          { poperrorskip("unterminated source code directive, missing *>"); BEGIN COMMENT; }
 <COMMENT><<EOF>>           { poperrorskip("unterminated comment found at the end of the file, missing *)"); BEGIN INITIAL; }
 
+"/*"                       { /* Possibly handle C preprocessor comment.  */
+                             if (cpreprocessor)
+			       {
+				 updatepos ();
+				 commentCLevel++;
+				 if (commentCLevel == 1)
+				   {
+				     pushLine ();
+				     skippos ();
+				   }
+				 BEGIN COMMENTC;
+			       }
+			     else
+			       splitSlashStar ();
+                           }
+<COMMENTC>.                { updatepos(); skippos(); }
+<COMMENTC>\n.*             { consumeLine(); }
+<COMMENTC>"*/"             { endOfCComment(); }
 ^\#.*                      { consumeLine(); /* printf("found: %s\n", currentLine->linebuf); */ BEGIN LINE0; }
 \n\#.*                     { consumeLine(); /* printf("found: %s\n", currentLine->linebuf); */ BEGIN LINE0; }
 <LINE0>\#[ \t]*            { updatepos(); }
@@ -436,6 +459,19 @@ static void endOfComment (void)
 }
 
 /*
+ *  endOfCComment - handles the end of C comment.
+ */
+
+static void endOfCComment (void)
+{
+  commentCLevel = 0;
+  updatepos();
+  skippos();
+  BEGIN INITIAL;
+  finishedLine();
+}
+
+/*
  *  m2flex_M2Error - displays the error message, s, after the code line and pointer
  *                   to the erroneous token.
  */
@@ -504,6 +540,39 @@ static void assert_location (location_t location ATTRIBUTE_UNUSED)
 }
 
 /*
+ *  splitSlashStar - called if we are not tokenizing source code after it
+ *                   has been preprocessed by cpp.  It is only called
+ *                   if the current token was a / immediately followed by * and
+ *                   therefore it will be split into two m2 tokens:  / and *.
+ */
+
+static void splitSlashStar (void)
+{
+  seenFunctionStart    = FALSE;
+  seenEnd              = FALSE;
+  seenModuleStart      = FALSE;
+  currentLine->nextpos = currentLine->tokenpos+1;  /* "/".  */
+  currentLine->toklen  = 1;
+  currentLine->column = currentLine->tokenpos+1;
+  currentLine->location =
+    M2Options_OverrideLocation (GET_LOCATION (currentLine->column,
+                                              currentLine->column+currentLine->toklen-1));
+  assert_location (GET_LOCATION (currentLine->column,
+                                 currentLine->column+currentLine->toklen-1));
+  M2LexBuf_AddTok (M2Reserved_dividetok);
+  currentLine->nextpos = currentLine->tokenpos+1;  /* "*".  */
+  currentLine->toklen  = 1;
+  currentLine->column = currentLine->tokenpos+1;
+  currentLine->location =
+    M2Options_OverrideLocation (GET_LOCATION (currentLine->column,
+                                              currentLine->column+currentLine->toklen-1));
+  assert_location (GET_LOCATION (currentLine->column,
+                                 currentLine->column+currentLine->toklen-1));
+  M2LexBuf_AddTok (M2Reserved_timestok);
+}
+
+
+/*
  *  updatepos - updates the current token position.
  *              Should be used when a rule matches a token.
  */
diff --git a/gcc/m2/m2pp.cc b/gcc/m2/m2pp.cc
index 2f49227..3f45180 100644
--- a/gcc/m2/m2pp.cc
+++ b/gcc/m2/m2pp.cc
@@ -547,6 +547,7 @@ m2pp_types (pretty *s)
     }
 }
 
+#ifdef DEBUGGING
 /* hextree displays the critical fields for function, block and
    bind_expr trees in raw hex.  */
 
@@ -607,6 +608,7 @@ hextree (tree t)
       killPretty (state);
     }
 }
+#endif
 
 /* translation produce a pseudo implementation module from the tree t.  */
 
diff --git a/gcc/m2/mc-boot-ch/Glibc.c b/gcc/m2/mc-boot-ch/Glibc.c
index 3e9b486..7a37fef 100644
--- a/gcc/m2/mc-boot-ch/Glibc.c
+++ b/gcc/m2/mc-boot-ch/Glibc.c
@@ -78,6 +78,20 @@ libc_strlen (char *s)
 }
 
 EXTERN
+time_t
+libc_time (time_t *buf)
+{
+  return time (buf);
+}
+
+EXTERN
+void *
+libc_localtime (time_t *epochtime)
+{
+  return localtime (epochtime);
+}
+
+EXTERN
 int
 libc_printf (char *_format, unsigned int _format_high, ...)
 {
diff --git a/gcc/m2/mc-boot/GArgs.c b/gcc/m2/mc-boot/GArgs.c
index 81955e8..bcb1b13 100644
--- a/gcc/m2/mc-boot/GArgs.c
+++ b/gcc/m2/mc-boot/GArgs.c
@@ -83,7 +83,7 @@ extern "C" unsigned int Args_GetArg (char *a, unsigned int _a_high, unsigned int
   if (i < (UnixArgs_GetArgC ()))
     {
       Source = static_cast<Args__T1> (UnixArgs_GetArgV ());
-      while (((*(*Source).array[i]).array[j] != ASCII_nul) && (j < High))
+      while ((j < High) && ((*(*Source).array[i]).array[j] != ASCII_nul))
         {
           a[j] = (*(*Source).array[i]).array[j];
           j += 1;
diff --git a/gcc/m2/mc-boot/GDynamicStrings.c b/gcc/m2/mc-boot/GDynamicStrings.c
index 372bbb5..a28b641 100644
--- a/gcc/m2/mc-boot/GDynamicStrings.c
+++ b/gcc/m2/mc-boot/GDynamicStrings.c
@@ -1214,7 +1214,7 @@ static void ConcatContents (DynamicStrings_Contents *c, const char *a_, unsigned
       (*c).next->contents.next = NULL;
       ConcatContents (&(*c).next->contents, (const char *) a, _a_high, h, o);
       AddDebugInfo ((*c).next);
-      (*c).next = AssignDebug ((*c).next, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/DynamicStrings.mod", 62, 722, (const char *) "ConcatContents", 14);
+      (*c).next = AssignDebug ((*c).next, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/DynamicStrings.mod", 55, 722, (const char *) "ConcatContents", 14);
     }
   else
     {
@@ -1312,7 +1312,7 @@ static void ConcatContentsAddress (DynamicStrings_Contents *c, void * a, unsigne
       AddDebugInfo ((*c).next);
       if (TraceOn)
         {
-          (*c).next = AssignDebug ((*c).next, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/DynamicStrings.mod", 62, 917, (const char *) "ConcatContentsAddress", 21);
+          (*c).next = AssignDebug ((*c).next, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/DynamicStrings.mod", 55, 917, (const char *) "ConcatContentsAddress", 21);
         }
     }
   else
@@ -1537,7 +1537,7 @@ extern "C" DynamicStrings_String DynamicStrings_InitString (const char *a_, unsi
   AddDebugInfo (s);
   if (TraceOn)
     {
-      s = AssignDebug (s, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/DynamicStrings.mod", 62, 758, (const char *) "InitString", 10);
+      s = AssignDebug (s, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/DynamicStrings.mod", 55, 758, (const char *) "InitString", 10);
     }
   return s;
   /* static analysis guarentees a RETURN statement will be used before here.  */
@@ -1640,7 +1640,7 @@ extern "C" DynamicStrings_String DynamicStrings_InitStringCharStar (void * a)
   AddDebugInfo (s);
   if (TraceOn)
     {
-      s = AssignDebug (s, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/DynamicStrings.mod", 62, 957, (const char *) "InitStringCharStar", 18);
+      s = AssignDebug (s, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/DynamicStrings.mod", 55, 957, (const char *) "InitStringCharStar", 18);
     }
   return s;
   /* static analysis guarentees a RETURN statement will be used before here.  */
@@ -1665,7 +1665,7 @@ extern "C" DynamicStrings_String DynamicStrings_InitStringChar (char ch)
   s = DynamicStrings_InitString ((const char *) &a.array[0], 1);
   if (TraceOn)
     {
-      s = AssignDebug (s, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/DynamicStrings.mod", 62, 977, (const char *) "InitStringChar", 14);
+      s = AssignDebug (s, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/DynamicStrings.mod", 55, 977, (const char *) "InitStringChar", 14);
     }
   return s;
   /* static analysis guarentees a RETURN statement will be used before here.  */
@@ -1823,7 +1823,7 @@ extern "C" DynamicStrings_String DynamicStrings_Dup (DynamicStrings_String s)
   s = DynamicStrings_Assign (DynamicStrings_InitString ((const char *) "", 0), s);
   if (TraceOn)
     {
-      s = AssignDebug (s, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/DynamicStrings.mod", 62, 1173, (const char *) "Dup", 3);
+      s = AssignDebug (s, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/DynamicStrings.mod", 55, 1173, (const char *) "Dup", 3);
     }
   return s;
   /* static analysis guarentees a RETURN statement will be used before here.  */
@@ -1845,7 +1845,7 @@ extern "C" DynamicStrings_String DynamicStrings_Add (DynamicStrings_String a, Dy
   a = DynamicStrings_ConCat (DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "", 0), a), b);
   if (TraceOn)
     {
-      a = AssignDebug (a, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/DynamicStrings.mod", 62, 1193, (const char *) "Add", 3);
+      a = AssignDebug (a, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/DynamicStrings.mod", 55, 1193, (const char *) "Add", 3);
     }
   return a;
   /* static analysis guarentees a RETURN statement will be used before here.  */
@@ -1874,16 +1874,6 @@ extern "C" unsigned int DynamicStrings_Equal (DynamicStrings_String a, DynamicSt
           Assertion_Assert (a->contents.len == b->contents.len);
           while (i < a->contents.len)
             {
-              if (a->contents.buf.array[i] != a->contents.buf.array[i])
-                {
-                  M2RTS_HALT (-1);
-                  __builtin_unreachable ();
-                }
-              if (b->contents.buf.array[i] != b->contents.buf.array[i])
-                {
-                  M2RTS_HALT (-1);
-                  __builtin_unreachable ();
-                }
               if (a->contents.buf.array[i] != b->contents.buf.array[i])
                 {
                   return FALSE;
@@ -1920,7 +1910,7 @@ extern "C" unsigned int DynamicStrings_EqualCharStar (DynamicStrings_String s, v
   t = DynamicStrings_InitStringCharStar (a);
   if (TraceOn)
     {
-      t = AssignDebug (t, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/DynamicStrings.mod", 62, 1258, (const char *) "EqualCharStar", 13);
+      t = AssignDebug (t, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/DynamicStrings.mod", 55, 1250, (const char *) "EqualCharStar", 13);
     }
   t = AddToGarbage (t, s);
   if (DynamicStrings_Equal (t, s))
@@ -1958,7 +1948,7 @@ extern "C" unsigned int DynamicStrings_EqualArray (DynamicStrings_String s, cons
   t = DynamicStrings_InitString ((const char *) a, _a_high);
   if (TraceOn)
     {
-      t = AssignDebug (t, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/DynamicStrings.mod", 62, 1288, (const char *) "EqualArray", 10);
+      t = AssignDebug (t, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/DynamicStrings.mod", 55, 1280, (const char *) "EqualArray", 10);
     }
   t = AddToGarbage (t, s);
   if (DynamicStrings_Equal (t, s))
@@ -1996,7 +1986,7 @@ extern "C" DynamicStrings_String DynamicStrings_Mult (DynamicStrings_String s, u
     }
   if (TraceOn)
     {
-      s = AssignDebug (s, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/DynamicStrings.mod", 62, 1320, (const char *) "Mult", 4);
+      s = AssignDebug (s, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/DynamicStrings.mod", 55, 1312, (const char *) "Mult", 4);
     }
   return s;
   /* static analysis guarentees a RETURN statement will be used before here.  */
@@ -2075,7 +2065,7 @@ extern "C" DynamicStrings_String DynamicStrings_Slice (DynamicStrings_String s,
                       AddDebugInfo (t->contents.next);
                       if (TraceOn)
                         {
-                          t->contents.next = AssignDebug (t->contents.next, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/DynamicStrings.mod", 62, 1388, (const char *) "Slice", 5);
+                          t->contents.next = AssignDebug (t->contents.next, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/DynamicStrings.mod", 55, 1380, (const char *) "Slice", 5);
                         }
                     }
                   t = t->contents.next;
@@ -2093,7 +2083,7 @@ extern "C" DynamicStrings_String DynamicStrings_Slice (DynamicStrings_String s,
     }
   if (TraceOn)
     {
-      d = AssignDebug (d, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/DynamicStrings.mod", 62, 1405, (const char *) "Slice", 5);
+      d = AssignDebug (d, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/DynamicStrings.mod", 55, 1397, (const char *) "Slice", 5);
     }
   return d;
   /* static analysis guarentees a RETURN statement will be used before here.  */
@@ -2221,7 +2211,7 @@ extern "C" DynamicStrings_String DynamicStrings_RemoveComment (DynamicStrings_St
     }
   if (TraceOn)
     {
-      s = AssignDebug (s, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/DynamicStrings.mod", 62, 1517, (const char *) "RemoveComment", 13);
+      s = AssignDebug (s, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/DynamicStrings.mod", 55, 1509, (const char *) "RemoveComment", 13);
     }
   return s;
   /* static analysis guarentees a RETURN statement will be used before here.  */
@@ -2246,7 +2236,7 @@ extern "C" DynamicStrings_String DynamicStrings_RemoveWhitePrefix (DynamicString
   s = DynamicStrings_Slice (s, (int ) (i), 0);
   if (TraceOn)
     {
-      s = AssignDebug (s, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/DynamicStrings.mod", 62, 1629, (const char *) "RemoveWhitePrefix", 17);
+      s = AssignDebug (s, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/DynamicStrings.mod", 55, 1621, (const char *) "RemoveWhitePrefix", 17);
     }
   return s;
   /* static analysis guarentees a RETURN statement will be used before here.  */
@@ -2271,7 +2261,7 @@ extern "C" DynamicStrings_String DynamicStrings_RemoveWhitePostfix (DynamicStrin
   s = DynamicStrings_Slice (s, 0, i+1);
   if (TraceOn)
     {
-      s = AssignDebug (s, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/DynamicStrings.mod", 62, 1651, (const char *) "RemoveWhitePostfix", 18);
+      s = AssignDebug (s, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/DynamicStrings.mod", 55, 1643, (const char *) "RemoveWhitePostfix", 18);
     }
   return s;
   /* static analysis guarentees a RETURN statement will be used before here.  */
@@ -2640,7 +2630,7 @@ extern "C" DynamicStrings_String DynamicStrings_PopAllocationExemption (unsigned
         {
           stop ();
           /* writeString ("mismatched number of PopAllocation's compared to PushAllocation's")  */
-          M2RTS_Halt ((const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/DynamicStrings.mod", 62, 176, (const char *) "PopAllocationExemption", 22, (const char *) "mismatched number of PopAllocation's compared to PushAllocation's", 65);
+          M2RTS_Halt ((const char *) "../../gcc-read-write/gcc/m2/gm2-libs/DynamicStrings.mod", 55, 176, (const char *) "PopAllocationExemption", 22, (const char *) "mismatched number of PopAllocation's compared to PushAllocation's", 65);
         }
       else
         {
diff --git a/gcc/m2/mc-boot/GFIO.c b/gcc/m2/mc-boot/GFIO.c
index e4c2ce0..74cd858 100644
--- a/gcc/m2/mc-boot/GFIO.c
+++ b/gcc/m2/mc-boot/GFIO.c
@@ -555,7 +555,7 @@ static FIO_File GetNextFreeDescriptor (void)
         return f;  /* create new slot  */
       }
   }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/FIO.def", 25, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/gm2-libs/FIO.def", 25, 1);
   __builtin_unreachable ();
 }
 
@@ -1703,7 +1703,7 @@ extern "C" unsigned int FIO_ReadNBytes (FIO_File f, unsigned int nBytes, void *
 extern "C" void FIO_ReadAny (FIO_File f, unsigned char *a, unsigned int _a_high)
 {
   CheckAccess (f, FIO_openedforread, FALSE);
-  if ((BufferedRead (f, _a_high, a)) == _a_high)
+  if ((BufferedRead (f, _a_high, a)) == ((int ) (_a_high)))
     {
       SetEndOfLine (f, static_cast<char> (a[_a_high]));
     }
@@ -1762,7 +1762,7 @@ extern "C" unsigned int FIO_WriteNBytes (FIO_File f, unsigned int nBytes, void *
 extern "C" void FIO_WriteAny (FIO_File f, unsigned char *a, unsigned int _a_high)
 {
   CheckAccess (f, FIO_openedforwrite, TRUE);
-  if ((BufferedWrite (f, _a_high, a)) == _a_high)
+  if ((BufferedWrite (f, _a_high, a)) == ((int ) (_a_high)))
     {}  /* empty.  */
 }
 
@@ -1774,7 +1774,7 @@ extern "C" void FIO_WriteAny (FIO_File f, unsigned char *a, unsigned int _a_high
 extern "C" void FIO_WriteChar (FIO_File f, char ch)
 {
   CheckAccess (f, FIO_openedforwrite, TRUE);
-  if ((BufferedWrite (f, sizeof (ch), &ch)) == sizeof (ch))
+  if ((BufferedWrite (f, sizeof (ch), &ch)) == ((int ) (sizeof (ch))))
     {}  /* empty.  */
 }
 
@@ -1873,7 +1873,7 @@ extern "C" char FIO_ReadChar (FIO_File f)
   char ch;
 
   CheckAccess (f, FIO_openedforread, FALSE);
-  if ((BufferedRead (f, sizeof (ch), &ch)) == sizeof (ch))
+  if ((BufferedRead (f, sizeof (ch), &ch)) == ((int ) (sizeof (ch))))
     {
       SetEndOfLine (f, ch);
       return ch;
@@ -2266,7 +2266,7 @@ extern "C" void * FIO_getFileName (FIO_File f)
           return fd->name.address;
         }
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/FIO.def", 25, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/gm2-libs/FIO.def", 25, 1);
   __builtin_unreachable ();
 }
 
@@ -2293,7 +2293,7 @@ extern "C" unsigned int FIO_getFileNameLength (FIO_File f)
           return fd->name.size;
         }
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/FIO.def", 25, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/gm2-libs/FIO.def", 25, 1);
   __builtin_unreachable ();
 }
 
diff --git a/gcc/m2/mc-boot/GFormatStrings.c b/gcc/m2/mc-boot/GFormatStrings.c
index a0b91e2..7710c8a 100644
--- a/gcc/m2/mc-boot/GFormatStrings.c
+++ b/gcc/m2/mc-boot/GFormatStrings.c
@@ -545,7 +545,7 @@ static DynamicStrings_String HandlePercent (DynamicStrings_String fmt, DynamicSt
   int prevpos;
   DynamicStrings_String result;
 
-  if ((startpos == (DynamicStrings_Length (fmt))) || (startpos < 0))
+  if ((startpos == ((int ) (DynamicStrings_Length (fmt)))) || (startpos < 0))
     {
       return s;
     }
diff --git a/gcc/m2/mc-boot/GIndexing.c b/gcc/m2/mc-boot/GIndexing.c
index 1c31581..c809e4b 100644
--- a/gcc/m2/mc-boot/GIndexing.c
+++ b/gcc/m2/mc-boot/GIndexing.c
@@ -222,7 +222,7 @@ extern "C" unsigned int Indexing_InBounds (Indexing_Index i, unsigned int n)
     {
       return (n >= i->Low) && (n <= i->High);
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/mc/Indexing.def", 20, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/mc/Indexing.def", 20, 1);
   __builtin_unreachable ();
 }
 
@@ -242,7 +242,7 @@ extern "C" unsigned int Indexing_HighIndice (Indexing_Index i)
     {
       return i->High;
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/mc/Indexing.def", 20, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/mc/Indexing.def", 20, 1);
   __builtin_unreachable ();
 }
 
@@ -262,7 +262,7 @@ extern "C" unsigned int Indexing_LowIndice (Indexing_Index i)
     {
       return i->Low;
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/mc/Indexing.def", 20, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/mc/Indexing.def", 20, 1);
   __builtin_unreachable ();
 }
 
diff --git a/gcc/m2/mc-boot/GM2Dependent.c b/gcc/m2/mc-boot/GM2Dependent.c
index 389da6a..fb22f1b 100644
--- a/gcc/m2/mc-boot/GM2Dependent.c
+++ b/gcc/m2/mc-boot/GM2Dependent.c
@@ -263,6 +263,13 @@ static void combine (M2Dependent_DependencyState src, M2Dependent_DependencyStat
 static void ForceDependencies (void);
 
 /*
+   CheckApplication - check to see that the application is the last entry in the list.
+                      This might happen if the application only imports FOR C modules.
+*/
+
+static void CheckApplication (void);
+
+/*
    equal - return TRUE if C string cstr is equal to str.
 */
 
@@ -450,7 +457,7 @@ static void toCString (char *str, unsigned int _str_high)
   high = _str_high;
   while (i < high)
     {
-      if ((str[i] == '\\') && (i < high))
+      if ((i < high) && (str[i] == '\\'))
         {
           if (str[i+1] == 'n')
             {
@@ -730,6 +737,7 @@ static void ResolveDependencies (void * currentmodule)
 static void DisplayModuleInfo (M2Dependent_DependencyState state, const char *name_, unsigned int _name_high)
 {
   M2Dependent_ModuleChain mptr;
+  unsigned int count;
   char name[_name_high+1];
 
   /* make a local copy of each unbounded array.  */
@@ -739,8 +747,10 @@ static void DisplayModuleInfo (M2Dependent_DependencyState state, const char *na
     {
       libc_printf ((const char *) "%s modules\\n", 12, &name);
       mptr = Modules.array[state-M2Dependent_unregistered];
+      count = 0;
       do {
-        libc_printf ((const char *) "  %s", 4, mptr->name);
+        libc_printf ((const char *) "  %d  %s", 8, count, mptr->name);
+        count += 1;
         if (mptr->dependency.appl)
           {
             libc_printf ((const char *) " application", 12);
@@ -852,6 +862,38 @@ static void ForceDependencies (void)
 
 
 /*
+   CheckApplication - check to see that the application is the last entry in the list.
+                      This might happen if the application only imports FOR C modules.
+*/
+
+static void CheckApplication (void)
+{
+  M2Dependent_ModuleChain mptr;
+  M2Dependent_ModuleChain appl;
+
+  mptr = Modules.array[M2Dependent_ordered-M2Dependent_unregistered];
+  if (mptr != NULL)
+    {
+      appl = NULL;
+      do {
+        if (mptr->dependency.appl)
+          {
+            appl = mptr;
+          }
+        else
+          {
+            mptr = mptr->next;
+          }
+      } while (! ((appl != NULL) || (mptr == Modules.array[M2Dependent_ordered-M2Dependent_unregistered])));
+      if (appl != NULL)
+        {
+          Modules.array[M2Dependent_ordered-M2Dependent_unregistered] = appl->next;
+        }
+    }
+}
+
+
+/*
    equal - return TRUE if C string cstr is equal to str.
 */
 
@@ -1006,6 +1048,9 @@ extern "C" void M2Dependent_ConstructModules (void * applicationmodule, int argc
   ForceDependencies ();
   traceprintf (ForceTrace, (const char *) "After user forcing ordering\\n", 29);
   DumpModuleData (ForceTrace);
+  CheckApplication ();
+  traceprintf (ForceTrace, (const char *) "After runtime forces application to the end\\n", 45);
+  DumpModuleData (ForceTrace);
   if (Modules.array[M2Dependent_ordered-M2Dependent_unregistered] == NULL)
     {
       traceprintf2 (ModuleTrace, (const char *) "  module: %s has not registered itself using a global constructor\\n", 67, applicationmodule);
diff --git a/gcc/m2/mc-boot/GM2EXCEPTION.c b/gcc/m2/mc-boot/GM2EXCEPTION.c
index 1339096..7915442 100644
--- a/gcc/m2/mc-boot/GM2EXCEPTION.c
+++ b/gcc/m2/mc-boot/GM2EXCEPTION.c
@@ -57,13 +57,13 @@ extern "C" M2EXCEPTION_M2Exceptions M2EXCEPTION_M2Exception (void)
   n = RTExceptions_GetNumber (e);
   if (n == (UINT_MAX))
     {
-      RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_exException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/M2EXCEPTION.mod")), 47, 6, const_cast<void*> (reinterpret_cast<const void*>("M2Exception")), const_cast<void*> (reinterpret_cast<const void*>("current coroutine is not in the exceptional execution state")));
+      RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_exException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-read-write/gcc/m2/gm2-libs/M2EXCEPTION.mod")), 47, 6, const_cast<void*> (reinterpret_cast<const void*>("M2Exception")), const_cast<void*> (reinterpret_cast<const void*>("current coroutine is not in the exceptional execution state")));
     }
   else
     {
       return (M2EXCEPTION_M2Exceptions) (n);
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/M2EXCEPTION.def", 25, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/gm2-libs/M2EXCEPTION.def", 25, 1);
   __builtin_unreachable ();
 }
 
diff --git a/gcc/m2/mc-boot/GM2RTS.c b/gcc/m2/mc-boot/GM2RTS.c
index 590656e..1b08741 100644
--- a/gcc/m2/mc-boot/GM2RTS.c
+++ b/gcc/m2/mc-boot/GM2RTS.c
@@ -61,6 +61,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 
 typedef struct M2RTS_ArgCVEnvP_p M2RTS_ArgCVEnvP;
 
+#   define stderrFd 2
 typedef struct M2RTS_ProcedureList_r M2RTS_ProcedureList;
 
 typedef char *M2RTS_PtrToChar;
@@ -175,10 +176,19 @@ extern "C" void M2RTS_HALT (int exitcode) __attribute__ ((noreturn));
 
 /*
    Halt - provides a more user friendly version of HALT, which takes
-          four parameters to aid debugging.
+          four parameters to aid debugging.  It writes an error message
+          to stderr and calls exit (1).
 */
 
-extern "C" void M2RTS_Halt (const char *file_, unsigned int _file_high, unsigned int line, const char *function_, unsigned int _function_high, const char *description_, unsigned int _description_high) __attribute__ ((noreturn));
+extern "C" void M2RTS_Halt (const char *filename_, unsigned int _filename_high, unsigned int line, const char *function_, unsigned int _function_high, const char *description_, unsigned int _description_high) __attribute__ ((noreturn));
+
+/*
+   HaltC - provides a more user friendly version of HALT, which takes
+           four parameters to aid debugging.  It writes an error message
+           to stderr and calls exit (1).
+*/
+
+extern "C" void M2RTS_HaltC (void * filename, unsigned int line, void * function, void * description);
 
 /*
    ExitOnHalt - if HALT is executed then call exit with the exit code, e.
@@ -190,7 +200,7 @@ extern "C" void M2RTS_ExitOnHalt (int e);
    ErrorMessage - emits an error message to stderr and then calls exit (1).
 */
 
-extern "C" void M2RTS_ErrorMessage (const char *message_, unsigned int _message_high, const char *file_, unsigned int _file_high, unsigned int line, const char *function_, unsigned int _function_high) __attribute__ ((noreturn));
+extern "C" void M2RTS_ErrorMessage (const char *message_, unsigned int _message_high, const char *filename_, unsigned int _filename_high, unsigned int line, const char *function_, unsigned int _function_high) __attribute__ ((noreturn));
 
 /*
    Length - returns the length of a string, a. This is called whenever
@@ -246,6 +256,18 @@ static unsigned int AppendProc (M2RTS_ProcedureList *proclist, PROC proc);
 static void ErrorString (const char *a_, unsigned int _a_high);
 
 /*
+   ErrorStringC - writes a string to stderr.
+*/
+
+static void ErrorStringC (void * str);
+
+/*
+   ErrorMessageC - emits an error message to stderr and then calls exit (1).
+*/
+
+static void ErrorMessageC (void * message, void * filename, unsigned int line, void * function) __attribute__ ((noreturn));
+
+/*
    InitProcList - initialize the head and tail pointers to NIL.
 */
 
@@ -319,7 +341,49 @@ static void ErrorString (const char *a_, unsigned int _a_high)
   /* make a local copy of each unbounded array.  */
   memcpy (a, a_, _a_high+1);
 
-  n = static_cast<int> (libc_write (2, &a, static_cast<size_t> (StrLib_StrLen ((const char *) a, _a_high))));
+  n = static_cast<int> (libc_write (stderrFd, &a, static_cast<size_t> (StrLib_StrLen ((const char *) a, _a_high))));
+}
+
+
+/*
+   ErrorStringC - writes a string to stderr.
+*/
+
+static void ErrorStringC (void * str)
+{
+  int len;
+
+  len = static_cast<int> (libc_write (stderrFd, str, libc_strlen (str)));
+}
+
+
+/*
+   ErrorMessageC - emits an error message to stderr and then calls exit (1).
+*/
+
+static void ErrorMessageC (void * message, void * filename, unsigned int line, void * function)
+{
+  typedef struct ErrorMessageC__T2_a ErrorMessageC__T2;
+
+  struct ErrorMessageC__T2_a { char array[10+1]; };
+  ErrorMessageC__T2 buffer;
+
+  ErrorStringC (filename);
+  ErrorString ((const char *) ":", 1);
+  NumberIO_CardToStr (line, 0, (char *) &buffer.array[0], 10);
+  ErrorString ((const char *) &buffer.array[0], 10);
+  ErrorString ((const char *) ":", 1);
+  if ((libc_strlen (function)) > 0)
+    {
+      ErrorString ((const char *) "in ", 3);
+      ErrorStringC (function);
+      ErrorString ((const char *) " has caused ", 12);
+    }
+  ErrorStringC (message);
+  buffer.array[0] = ASCII_nl;
+  buffer.array[1] = ASCII_nul;
+  ErrorString ((const char *) &buffer.array[0], 10);
+  libc_exit (1);
 }
 
 
@@ -516,23 +580,34 @@ extern "C" void M2RTS_HALT (int exitcode)
 
 /*
    Halt - provides a more user friendly version of HALT, which takes
-          four parameters to aid debugging.
+          four parameters to aid debugging.  It writes an error message
+          to stderr and calls exit (1).
 */
 
-extern "C" void M2RTS_Halt (const char *file_, unsigned int _file_high, unsigned int line, const char *function_, unsigned int _function_high, const char *description_, unsigned int _description_high)
+extern "C" void M2RTS_Halt (const char *filename_, unsigned int _filename_high, unsigned int line, const char *function_, unsigned int _function_high, const char *description_, unsigned int _description_high)
 {
-  char file[_file_high+1];
+  char filename[_filename_high+1];
   char function[_function_high+1];
   char description[_description_high+1];
 
   /* make a local copy of each unbounded array.  */
-  memcpy (file, file_, _file_high+1);
+  memcpy (filename, filename_, _filename_high+1);
   memcpy (function, function_, _function_high+1);
   memcpy (description, description_, _description_high+1);
 
-  M2RTS_ErrorMessage ((const char *) description, _description_high, (const char *) file, _file_high, line, (const char *) function, _function_high);
-  M2RTS_HALT (-1);
-  __builtin_unreachable ();
+  M2RTS_ErrorMessage ((const char *) description, _description_high, (const char *) filename, _filename_high, line, (const char *) function, _function_high);
+}
+
+
+/*
+   HaltC - provides a more user friendly version of HALT, which takes
+           four parameters to aid debugging.  It writes an error message
+           to stderr and calls exit (1).
+*/
+
+extern "C" void M2RTS_HaltC (void * filename, unsigned int line, void * function, void * description)
+{
+  ErrorMessageC (description, filename, line, function);
 }
 
 
@@ -551,25 +626,25 @@ extern "C" void M2RTS_ExitOnHalt (int e)
    ErrorMessage - emits an error message to stderr and then calls exit (1).
 */
 
-extern "C" void M2RTS_ErrorMessage (const char *message_, unsigned int _message_high, const char *file_, unsigned int _file_high, unsigned int line, const char *function_, unsigned int _function_high)
+extern "C" void M2RTS_ErrorMessage (const char *message_, unsigned int _message_high, const char *filename_, unsigned int _filename_high, unsigned int line, const char *function_, unsigned int _function_high)
 {
-  typedef struct ErrorMessage__T2_a ErrorMessage__T2;
+  typedef struct ErrorMessage__T3_a ErrorMessage__T3;
 
-  struct ErrorMessage__T2_a { char array[10+1]; };
-  ErrorMessage__T2 LineNo;
+  struct ErrorMessage__T3_a { char array[10+1]; };
+  ErrorMessage__T3 buffer;
   char message[_message_high+1];
-  char file[_file_high+1];
+  char filename[_filename_high+1];
   char function[_function_high+1];
 
   /* make a local copy of each unbounded array.  */
   memcpy (message, message_, _message_high+1);
-  memcpy (file, file_, _file_high+1);
+  memcpy (filename, filename_, _filename_high+1);
   memcpy (function, function_, _function_high+1);
 
-  ErrorString ((const char *) file, _file_high);
+  ErrorString ((const char *) filename, _filename_high);
   ErrorString ((const char *) ":", 1);
-  NumberIO_CardToStr (line, 0, (char *) &LineNo.array[0], 10);
-  ErrorString ((const char *) &LineNo.array[0], 10);
+  NumberIO_CardToStr (line, 0, (char *) &buffer.array[0], 10);
+  ErrorString ((const char *) &buffer.array[0], 10);
   ErrorString ((const char *) ":", 1);
   if (! (StrLib_StrEqual ((const char *) function, _function_high, (const char *) "", 0)))
     {
@@ -578,9 +653,9 @@ extern "C" void M2RTS_ErrorMessage (const char *message_, unsigned int _message_
       ErrorString ((const char *) " has caused ", 12);
     }
   ErrorString ((const char *) message, _message_high);
-  LineNo.array[0] = ASCII_nl;
-  LineNo.array[1] = ASCII_nul;
-  ErrorString ((const char *) &LineNo.array[0], 10);
+  buffer.array[0] = ASCII_nl;
+  buffer.array[1] = ASCII_nul;
+  ErrorString ((const char *) &buffer.array[0], 10);
   libc_exit (1);
 }
 
diff --git a/gcc/m2/mc-boot/GM2RTS.h b/gcc/m2/mc-boot/GM2RTS.h
index 698f142..5db589e 100644
--- a/gcc/m2/mc-boot/GM2RTS.h
+++ b/gcc/m2/mc-boot/GM2RTS.h
@@ -126,10 +126,19 @@ EXTERN void M2RTS_HALT (int exitcode) __attribute__ ((noreturn));
 
 /*
    Halt - provides a more user friendly version of HALT, which takes
-          four parameters to aid debugging.
+           four parameters to aid debugging.  It writes an error message
+           to stderr and calls exit (1).
 */
 
-EXTERN void M2RTS_Halt (const char *file_, unsigned int _file_high, unsigned int line, const char *function_, unsigned int _function_high, const char *description_, unsigned int _description_high) __attribute__ ((noreturn));
+EXTERN void M2RTS_Halt (const char *filename_, unsigned int _filename_high, unsigned int line, const char *function_, unsigned int _function_high, const char *description_, unsigned int _description_high) __attribute__ ((noreturn));
+
+/*
+   HaltC - provides a more user friendly version of HALT, which takes
+           four parameters to aid debugging.  It writes an error message
+           to stderr and calls exit (1).
+*/
+
+EXTERN void M2RTS_HaltC (void * filename, unsigned int line, void * function, void * description);
 
 /*
    ExitOnHalt - if HALT is executed then call exit with the exit code, e.
@@ -141,7 +150,7 @@ EXTERN void M2RTS_ExitOnHalt (int e);
    ErrorMessage - emits an error message to stderr and then calls exit (1).
 */
 
-EXTERN void M2RTS_ErrorMessage (const char *message_, unsigned int _message_high, const char *file_, unsigned int _file_high, unsigned int line, const char *function_, unsigned int _function_high) __attribute__ ((noreturn));
+EXTERN void M2RTS_ErrorMessage (const char *message_, unsigned int _message_high, const char *filename_, unsigned int _filename_high, unsigned int line, const char *function_, unsigned int _function_high) __attribute__ ((noreturn));
 
 /*
    Length - returns the length of a string, a. This is called whenever
diff --git a/gcc/m2/mc-boot/GPushBackInput.c b/gcc/m2/mc-boot/GPushBackInput.c
index 1e75ede..6812343 100644
--- a/gcc/m2/mc-boot/GPushBackInput.c
+++ b/gcc/m2/mc-boot/GPushBackInput.c
@@ -274,7 +274,7 @@ extern "C" char PushBackInput_PutCh (char ch)
     }
   else
     {
-      Debug_Halt ((const char *) "max push back stack exceeded, increase MaxPushBackStack", 55, 150, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/PushBackInput.mod", 61);
+      Debug_Halt ((const char *) "max push back stack exceeded, increase MaxPushBackStack", 55, 150, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/PushBackInput.mod", 54);
     }
   return ch;
   /* static analysis guarentees a RETURN statement will be used before here.  */
@@ -300,7 +300,7 @@ extern "C" void PushBackInput_PutString (const char *a_, unsigned int _a_high)
       l -= 1;
       if ((PushBackInput_PutCh (a[l])) != a[l])
         {
-          Debug_Halt ((const char *) "assert failed", 13, 132, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/PushBackInput.mod", 61);
+          Debug_Halt ((const char *) "assert failed", 13, 132, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/PushBackInput.mod", 54);
         }
     }
 }
@@ -321,7 +321,7 @@ extern "C" void PushBackInput_PutStr (DynamicStrings_String s)
       i -= 1;
       if ((PushBackInput_PutCh (DynamicStrings_char (s, static_cast<int> (i)))) != (DynamicStrings_char (s, static_cast<int> (i))))
         {
-          Debug_Halt ((const char *) "assert failed", 13, 113, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/PushBackInput.mod", 61);
+          Debug_Halt ((const char *) "assert failed", 13, 113, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/PushBackInput.mod", 54);
         }
     }
 }
diff --git a/gcc/m2/mc-boot/GRTExceptions.c b/gcc/m2/mc-boot/GRTExceptions.c
index 0ca1a18..a6aa806 100644
--- a/gcc/m2/mc-boot/GRTExceptions.c
+++ b/gcc/m2/mc-boot/GRTExceptions.c
@@ -719,7 +719,7 @@ static void AddHandler (RTExceptions_EHBlock e, RTExceptions_Handler h)
 
 static void indexf (void * a)
 {
-  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_indexException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTExceptions.mod")), 612, 9, const_cast<void*> (reinterpret_cast<const void*>("indexf")), const_cast<void*> (reinterpret_cast<const void*>("array index out of bounds")));
+  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_indexException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-read-write/gcc/m2/gm2-libs/RTExceptions.mod")), 612, 9, const_cast<void*> (reinterpret_cast<const void*>("indexf")), const_cast<void*> (reinterpret_cast<const void*>("array index out of bounds")));
 }
 
 
@@ -729,7 +729,7 @@ static void indexf (void * a)
 
 static void range (void * a)
 {
-  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_rangeException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTExceptions.mod")), 624, 9, const_cast<void*> (reinterpret_cast<const void*>("range")), const_cast<void*> (reinterpret_cast<const void*>("assignment out of range")));
+  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_rangeException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-read-write/gcc/m2/gm2-libs/RTExceptions.mod")), 624, 9, const_cast<void*> (reinterpret_cast<const void*>("range")), const_cast<void*> (reinterpret_cast<const void*>("assignment out of range")));
 }
 
 
@@ -739,7 +739,7 @@ static void range (void * a)
 
 static void casef (void * a)
 {
-  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_caseSelectException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTExceptions.mod")), 636, 9, const_cast<void*> (reinterpret_cast<const void*>("casef")), const_cast<void*> (reinterpret_cast<const void*>("case selector out of range")));
+  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_caseSelectException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-read-write/gcc/m2/gm2-libs/RTExceptions.mod")), 636, 9, const_cast<void*> (reinterpret_cast<const void*>("casef")), const_cast<void*> (reinterpret_cast<const void*>("case selector out of range")));
 }
 
 
@@ -749,7 +749,7 @@ static void casef (void * a)
 
 static void invalidloc (void * a)
 {
-  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_invalidLocation)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTExceptions.mod")), 648, 9, const_cast<void*> (reinterpret_cast<const void*>("invalidloc")), const_cast<void*> (reinterpret_cast<const void*>("invalid address referenced")));
+  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_invalidLocation)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-read-write/gcc/m2/gm2-libs/RTExceptions.mod")), 648, 9, const_cast<void*> (reinterpret_cast<const void*>("invalidloc")), const_cast<void*> (reinterpret_cast<const void*>("invalid address referenced")));
 }
 
 
@@ -759,7 +759,7 @@ static void invalidloc (void * a)
 
 static void function (void * a)
 {
-  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_functionException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTExceptions.mod")), 660, 9, const_cast<void*> (reinterpret_cast<const void*>("function")), const_cast<void*> (reinterpret_cast<const void*>("... function ... ")));  /* --fixme-- what has happened ?  */
+  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_functionException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-read-write/gcc/m2/gm2-libs/RTExceptions.mod")), 660, 9, const_cast<void*> (reinterpret_cast<const void*>("function")), const_cast<void*> (reinterpret_cast<const void*>("... function ... ")));  /* --fixme-- what has happened ?  */
 }
 
 
@@ -769,7 +769,7 @@ static void function (void * a)
 
 static void wholevalue (void * a)
 {
-  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_wholeValueException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTExceptions.mod")), 672, 9, const_cast<void*> (reinterpret_cast<const void*>("wholevalue")), const_cast<void*> (reinterpret_cast<const void*>("illegal whole value exception")));
+  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_wholeValueException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-read-write/gcc/m2/gm2-libs/RTExceptions.mod")), 672, 9, const_cast<void*> (reinterpret_cast<const void*>("wholevalue")), const_cast<void*> (reinterpret_cast<const void*>("illegal whole value exception")));
 }
 
 
@@ -779,7 +779,7 @@ static void wholevalue (void * a)
 
 static void wholediv (void * a)
 {
-  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_wholeDivException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTExceptions.mod")), 684, 9, const_cast<void*> (reinterpret_cast<const void*>("wholediv")), const_cast<void*> (reinterpret_cast<const void*>("illegal whole value exception")));
+  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_wholeDivException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-read-write/gcc/m2/gm2-libs/RTExceptions.mod")), 684, 9, const_cast<void*> (reinterpret_cast<const void*>("wholediv")), const_cast<void*> (reinterpret_cast<const void*>("illegal whole value exception")));
 }
 
 
@@ -789,7 +789,7 @@ static void wholediv (void * a)
 
 static void realvalue (void * a)
 {
-  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_realValueException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTExceptions.mod")), 696, 9, const_cast<void*> (reinterpret_cast<const void*>("realvalue")), const_cast<void*> (reinterpret_cast<const void*>("illegal real value exception")));
+  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_realValueException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-read-write/gcc/m2/gm2-libs/RTExceptions.mod")), 696, 9, const_cast<void*> (reinterpret_cast<const void*>("realvalue")), const_cast<void*> (reinterpret_cast<const void*>("illegal real value exception")));
 }
 
 
@@ -799,7 +799,7 @@ static void realvalue (void * a)
 
 static void realdiv (void * a)
 {
-  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_realDivException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTExceptions.mod")), 708, 9, const_cast<void*> (reinterpret_cast<const void*>("realdiv")), const_cast<void*> (reinterpret_cast<const void*>("real number division by zero exception")));
+  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_realDivException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-read-write/gcc/m2/gm2-libs/RTExceptions.mod")), 708, 9, const_cast<void*> (reinterpret_cast<const void*>("realdiv")), const_cast<void*> (reinterpret_cast<const void*>("real number division by zero exception")));
 }
 
 
@@ -809,7 +809,7 @@ static void realdiv (void * a)
 
 static void complexvalue (void * a)
 {
-  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_complexValueException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTExceptions.mod")), 720, 9, const_cast<void*> (reinterpret_cast<const void*>("complexvalue")), const_cast<void*> (reinterpret_cast<const void*>("illegal complex value exception")));
+  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_complexValueException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-read-write/gcc/m2/gm2-libs/RTExceptions.mod")), 720, 9, const_cast<void*> (reinterpret_cast<const void*>("complexvalue")), const_cast<void*> (reinterpret_cast<const void*>("illegal complex value exception")));
 }
 
 
@@ -819,7 +819,7 @@ static void complexvalue (void * a)
 
 static void complexdiv (void * a)
 {
-  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_complexDivException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTExceptions.mod")), 732, 9, const_cast<void*> (reinterpret_cast<const void*>("complexdiv")), const_cast<void*> (reinterpret_cast<const void*>("complex number division by zero exception")));
+  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_complexDivException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-read-write/gcc/m2/gm2-libs/RTExceptions.mod")), 732, 9, const_cast<void*> (reinterpret_cast<const void*>("complexdiv")), const_cast<void*> (reinterpret_cast<const void*>("complex number division by zero exception")));
 }
 
 
@@ -829,7 +829,7 @@ static void complexdiv (void * a)
 
 static void protection (void * a)
 {
-  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_protException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTExceptions.mod")), 744, 9, const_cast<void*> (reinterpret_cast<const void*>("protection")), const_cast<void*> (reinterpret_cast<const void*>("protection exception")));
+  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_protException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-read-write/gcc/m2/gm2-libs/RTExceptions.mod")), 744, 9, const_cast<void*> (reinterpret_cast<const void*>("protection")), const_cast<void*> (reinterpret_cast<const void*>("protection exception")));
 }
 
 
@@ -839,7 +839,7 @@ static void protection (void * a)
 
 static void systemf (void * a)
 {
-  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_sysException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTExceptions.mod")), 756, 9, const_cast<void*> (reinterpret_cast<const void*>("systemf")), const_cast<void*> (reinterpret_cast<const void*>("system exception")));
+  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_sysException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-read-write/gcc/m2/gm2-libs/RTExceptions.mod")), 756, 9, const_cast<void*> (reinterpret_cast<const void*>("systemf")), const_cast<void*> (reinterpret_cast<const void*>("system exception")));
 }
 
 
@@ -849,7 +849,7 @@ static void systemf (void * a)
 
 static void coroutine (void * a)
 {
-  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_coException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTExceptions.mod")), 768, 9, const_cast<void*> (reinterpret_cast<const void*>("coroutine")), const_cast<void*> (reinterpret_cast<const void*>("coroutine exception")));
+  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_coException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-read-write/gcc/m2/gm2-libs/RTExceptions.mod")), 768, 9, const_cast<void*> (reinterpret_cast<const void*>("coroutine")), const_cast<void*> (reinterpret_cast<const void*>("coroutine exception")));
 }
 
 
@@ -859,7 +859,7 @@ static void coroutine (void * a)
 
 static void exception (void * a)
 {
-  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_exException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTExceptions.mod")), 780, 9, const_cast<void*> (reinterpret_cast<const void*>("exception")), const_cast<void*> (reinterpret_cast<const void*>("exception exception")));
+  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_exException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-read-write/gcc/m2/gm2-libs/RTExceptions.mod")), 780, 9, const_cast<void*> (reinterpret_cast<const void*>("exception")), const_cast<void*> (reinterpret_cast<const void*>("exception exception")));
 }
 
 
@@ -1178,13 +1178,13 @@ extern "C" RTExceptions_EHBlock RTExceptions_GetBaseExceptionBlock (void)
 {
   if (currentEHB == NULL)
     {
-      M2RTS_Halt ((const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTExceptions.mod", 60, 598, (const char *) "GetBaseExceptionBlock", 21, (const char *) "currentEHB has not been initialized yet", 39);
+      M2RTS_Halt ((const char *) "../../gcc-read-write/gcc/m2/gm2-libs/RTExceptions.mod", 53, 598, (const char *) "GetBaseExceptionBlock", 21, (const char *) "currentEHB has not been initialized yet", 39);
     }
   else
     {
       return currentEHB;
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTExceptions.def", 25, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/gm2-libs/RTExceptions.def", 25, 1);
   __builtin_unreachable ();
 }
 
diff --git a/gcc/m2/mc-boot/GRTint.c b/gcc/m2/mc-boot/GRTint.c
index 00b0e6b..d8cac27 100644
--- a/gcc/m2/mc-boot/GRTint.c
+++ b/gcc/m2/mc-boot/GRTint.c
@@ -595,7 +595,7 @@ static unsigned int activatePending (unsigned int untilInterrupt, RTint_Dispatch
 
 
               default:
-                CaseException ("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTint.def", 25, 1);
+                CaseException ("../../gcc-read-write/gcc/m2/gm2-libs/RTint.def", 25, 1);
                 __builtin_unreachable ();
             }
           v = v->pending;
@@ -708,7 +708,7 @@ extern "C" unsigned int RTint_InitOutputVector (int fd, unsigned int pri)
       RTco_signal (lock);
       return v->no;
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTint.def", 25, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/gm2-libs/RTint.def", 25, 1);
   __builtin_unreachable ();
 }
 
@@ -765,7 +765,7 @@ extern "C" void RTint_ReArmTimeVector (unsigned int vec, unsigned int micro, uns
   v = FindVectorNo (vec);
   if (v == NULL)
     {
-      M2RTS_Halt ((const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTint.mod", 53, 286, (const char *) "ReArmTimeVector", 15, (const char *) "cannot find vector supplied", 27);
+      M2RTS_Halt ((const char *) "../../gcc-read-write/gcc/m2/gm2-libs/RTint.mod", 46, 286, (const char *) "ReArmTimeVector", 15, (const char *) "cannot find vector supplied", 27);
     }
   else
     {
@@ -790,7 +790,7 @@ extern "C" void RTint_GetTimeVector (unsigned int vec, unsigned int *micro, unsi
   v = FindVectorNo (vec);
   if (v == NULL)
     {
-      M2RTS_Halt ((const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTint.mod", 53, 312, (const char *) "GetTimeVector", 13, (const char *) "cannot find vector supplied", 27);
+      M2RTS_Halt ((const char *) "../../gcc-read-write/gcc/m2/gm2-libs/RTint.mod", 46, 312, (const char *) "GetTimeVector", 13, (const char *) "cannot find vector supplied", 27);
     }
   else
     {
@@ -816,7 +816,7 @@ extern "C" void * RTint_AttachVector (unsigned int vec, void * p)
   v = FindVectorNo (vec);
   if (v == NULL)
     {
-      M2RTS_Halt ((const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTint.mod", 53, 339, (const char *) "AttachVector", 12, (const char *) "cannot find vector supplied", 27);
+      M2RTS_Halt ((const char *) "../../gcc-read-write/gcc/m2/gm2-libs/RTint.mod", 46, 339, (const char *) "AttachVector", 12, (const char *) "cannot find vector supplied", 27);
     }
   else
     {
@@ -830,7 +830,7 @@ extern "C" void * RTint_AttachVector (unsigned int vec, void * p)
       RTco_signal (lock);
       return l;
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTint.def", 25, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/gm2-libs/RTint.def", 25, 1);
   __builtin_unreachable ();
 }
 
@@ -855,7 +855,7 @@ extern "C" void RTint_IncludeVector (unsigned int vec)
       v = FindVectorNo (vec);
       if (v == NULL)
         {
-          M2RTS_Halt ((const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTint.mod", 53, 372, (const char *) "IncludeVector", 13, (const char *) "cannot find vector supplied", 27);
+          M2RTS_Halt ((const char *) "../../gcc-read-write/gcc/m2/gm2-libs/RTint.mod", 46, 372, (const char *) "IncludeVector", 13, (const char *) "cannot find vector supplied", 27);
         }
       else
         {
@@ -902,7 +902,7 @@ extern "C" void RTint_ExcludeVector (unsigned int vec)
   v = FindPendingVector (vec);
   if (v == NULL)
     {
-      M2RTS_Halt ((const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTint.mod", 53, 415, (const char *) "ExcludeVector", 13, (const char *) "cannot find pending vector supplied", 35);
+      M2RTS_Halt ((const char *) "../../gcc-read-write/gcc/m2/gm2-libs/RTint.mod", 46, 415, (const char *) "ExcludeVector", 13, (const char *) "cannot find pending vector supplied", 35);
     }
   else
     {
@@ -1003,7 +1003,7 @@ extern "C" void RTint_Listen (unsigned int untilInterrupt, RTint_DispatchVector
 
 
                   default:
-                    CaseException ("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTint.def", 25, 1);
+                    CaseException ("../../gcc-read-write/gcc/m2/gm2-libs/RTint.def", 25, 1);
                     __builtin_unreachable ();
                 }
               v = v->pending;
@@ -1016,7 +1016,7 @@ extern "C" void RTint_Listen (unsigned int untilInterrupt, RTint_DispatchVector
         }
       if (((untilInterrupt && (i == NULL)) && (o == NULL)) && ! found)
         {
-          M2RTS_Halt ((const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTint.mod", 53, 731, (const char *) "Listen", 6, (const char *) "deadlock found, no more processes to run and no interrupts active", 65);
+          M2RTS_Halt ((const char *) "../../gcc-read-write/gcc/m2/gm2-libs/RTint.mod", 46, 731, (const char *) "Listen", 6, (const char *) "deadlock found, no more processes to run and no interrupts active", 65);
         }
       /* printf('}
       ') ;  */
diff --git a/gcc/m2/mc-boot/GStdIO.c b/gcc/m2/mc-boot/GStdIO.c
index d3891c2..8bb03af 100644
--- a/gcc/m2/mc-boot/GStdIO.c
+++ b/gcc/m2/mc-boot/GStdIO.c
@@ -193,7 +193,7 @@ extern "C" StdIO_ProcWrite StdIO_GetCurrentOutput (void)
       M2RTS_HALT (-1);
       __builtin_unreachable ();
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/StdIO.def", 25, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/gm2-libs/StdIO.def", 25, 1);
   __builtin_unreachable ();
 }
 
@@ -252,7 +252,7 @@ extern "C" StdIO_ProcRead StdIO_GetCurrentInput (void)
       M2RTS_HALT (-1);
       __builtin_unreachable ();
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/StdIO.def", 25, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/gm2-libs/StdIO.def", 25, 1);
   __builtin_unreachable ();
 }
 
diff --git a/gcc/m2/mc-boot/GStringConvert.c b/gcc/m2/mc-boot/GStringConvert.c
index 03b780e..8b87e0b 100644
--- a/gcc/m2/mc-boot/GStringConvert.c
+++ b/gcc/m2/mc-boot/GStringConvert.c
@@ -1916,7 +1916,7 @@ extern "C" DynamicStrings_String StringConvert_ToSigFig (DynamicStrings_String s
   int point;
   unsigned int poTen;
 
-  Assert ((IsDigit (DynamicStrings_char (s, 0))) || ((DynamicStrings_char (s, 0)) == '.'), (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/StringConvert.mod", 61, 1222, (const char *) "ToSigFig", 8);
+  Assert ((IsDigit (DynamicStrings_char (s, 0))) || ((DynamicStrings_char (s, 0)) == '.'), (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/StringConvert.mod", 54, 1222, (const char *) "ToSigFig", 8);
   point = DynamicStrings_Index (s, '.', 0);
   if (point < 0)
     {
@@ -1968,7 +1968,7 @@ extern "C" DynamicStrings_String StringConvert_ToDecimalPlaces (DynamicStrings_S
 {
   int point;
 
-  Assert ((IsDigit (DynamicStrings_char (s, 0))) || ((DynamicStrings_char (s, 0)) == '.'), (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/StringConvert.mod", 61, 1069, (const char *) "ToDecimalPlaces", 15);
+  Assert ((IsDigit (DynamicStrings_char (s, 0))) || ((DynamicStrings_char (s, 0)) == '.'), (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/StringConvert.mod", 54, 1069, (const char *) "ToDecimalPlaces", 15);
   point = DynamicStrings_Index (s, '.', 0);
   if (point < 0)
     {
diff --git a/gcc/m2/mc-boot/GSysStorage.c b/gcc/m2/mc-boot/GSysStorage.c
index db79dd7..d5218fb 100644
--- a/gcc/m2/mc-boot/GSysStorage.c
+++ b/gcc/m2/mc-boot/GSysStorage.c
@@ -93,7 +93,7 @@ extern "C" void SysStorage_ALLOCATE (void * *a, unsigned int size)
   (*a) = libc_malloc (static_cast<size_t> (size));
   if ((*a) == NULL)
     {
-      Debug_Halt ((const char *) "out of memory error", 19, 50, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/SysStorage.mod", 58);
+      Debug_Halt ((const char *) "out of memory error", 19, 50, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/SysStorage.mod", 51);
     }
   if (enableTrace && trace)
     {
@@ -118,7 +118,7 @@ extern "C" void SysStorage_DEALLOCATE (void * *a, unsigned int size)
         }
       if ((libc_memset ((*a), 0, static_cast<size_t> (size))) != (*a))
         {
-          Debug_Halt ((const char *) "memset should have returned the first parameter", 47, 76, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/SysStorage.mod", 58);
+          Debug_Halt ((const char *) "memset should have returned the first parameter", 47, 76, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/SysStorage.mod", 51);
         }
     }
   if (enableDeallocation)
@@ -163,7 +163,7 @@ extern "C" void SysStorage_REALLOCATE (void * *a, unsigned int size)
       (*a) = libc_realloc ((*a), static_cast<size_t> (size));
       if ((*a) == NULL)
         {
-          Debug_Halt ((const char *) "out of memory error", 19, 119, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/SysStorage.mod", 58);
+          Debug_Halt ((const char *) "out of memory error", 19, 119, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/SysStorage.mod", 51);
         }
       if (enableTrace && trace)
         {
diff --git a/gcc/m2/mc-boot/Gdecl.c b/gcc/m2/mc-boot/Gdecl.c
index 985444a..6511cbb 100644
--- a/gcc/m2/mc-boot/Gdecl.c
+++ b/gcc/m2/mc-boot/Gdecl.c
@@ -56,6 +56,7 @@ typedef struct mcPretty_writeLnProc_p mcPretty_writeLnProc;
 typedef unsigned int FIO_File;
 
 extern FIO_File FIO_StdOut;
+#   define symbolKey_NulKey NULL
 typedef struct symbolKey_performOperation_p symbolKey_performOperation;
 
 #   define ASCII_tab ASCII_ht
@@ -76,7 +77,6 @@ typedef struct decl_isNodeF_p decl_isNodeF;
 #   define SYSTEM_BYTESPERWORD 4
 typedef struct M2RTS_ArgCVEnvP_p M2RTS_ArgCVEnvP;
 
-#   define symbolKey_NulKey NULL
 typedef struct symbolKey_isSymbol_p symbolKey_isSymbol;
 
 #   define ASCII_nul (char) 000
@@ -293,16 +293,16 @@ typedef enum {mcComment_unknown, mcComment_procedureHeading, mcComment_inBody, m
 
 typedef struct DynamicStrings_stringRecord_r DynamicStrings_stringRecord;
 
+typedef struct DynamicStrings_Contents_r DynamicStrings_Contents;
+
 typedef struct wlists__T9_r wlists__T9;
 
 typedef struct mcPretty__T12_r mcPretty__T12;
 
-typedef struct DynamicStrings_Contents_r DynamicStrings_Contents;
+typedef struct wlists__T10_a wlists__T10;
 
 typedef struct DynamicStrings__T7_a DynamicStrings__T7;
 
-typedef struct wlists__T10_a wlists__T10;
-
 typedef Indexing__T5 *Indexing_Index;
 
 typedef mcComment__T6 *mcComment_commentDesc;
@@ -665,8 +665,8 @@ struct mcComment__T6_r {
                          unsigned int used;
                        };
 
-struct DynamicStrings__T7_a { char array[(MaxBuf-1)+1]; };
 struct wlists__T10_a { unsigned int array[maxNoOfElements-1+1]; };
+struct DynamicStrings__T7_a { char array[(MaxBuf-1)+1]; };
 struct alists__T13_r {
                        unsigned int noOfelements;
                        alists__T14 elements;
@@ -830,6 +830,12 @@ struct decl_impT_r {
                      decl_commentPair com;
                    };
 
+struct DynamicStrings_Contents_r {
+                                   DynamicStrings__T7 buf;
+                                   unsigned int len;
+                                   DynamicStrings_String next;
+                                 };
+
 struct wlists__T9_r {
                       unsigned int noOfElements;
                       wlists__T10 elements;
@@ -848,12 +854,6 @@ struct mcPretty__T12_r {
                          mcPretty_pretty stacked;
                        };
 
-struct DynamicStrings_Contents_r {
-                                   DynamicStrings__T7 buf;
-                                   unsigned int len;
-                                   DynamicStrings_String next;
-                                 };
-
 typedef struct DynamicStrings_descriptor_r DynamicStrings_descriptor;
 
 typedef DynamicStrings_descriptor *DynamicStrings_Descriptor;
@@ -1037,9 +1037,10 @@ extern "C" unsigned int M2RTS_InstallInitialProcedure (PROC p);
 extern "C" void M2RTS_ExecuteTerminationProcedures (void);
 extern "C" void M2RTS_Terminate (void) __attribute__ ((noreturn));
 extern "C" void M2RTS_HALT (int exitcode) __attribute__ ((noreturn));
-extern "C" void M2RTS_Halt (const char *file_, unsigned int _file_high, unsigned int line, const char *function_, unsigned int _function_high, const char *description_, unsigned int _description_high) __attribute__ ((noreturn));
+extern "C" void M2RTS_Halt (const char *filename_, unsigned int _filename_high, unsigned int line, const char *function_, unsigned int _function_high, const char *description_, unsigned int _description_high) __attribute__ ((noreturn));
+extern "C" void M2RTS_HaltC (void * filename, unsigned int line, void * function, void * description);
 extern "C" void M2RTS_ExitOnHalt (int e);
-extern "C" void M2RTS_ErrorMessage (const char *message_, unsigned int _message_high, const char *file_, unsigned int _file_high, unsigned int line, const char *function_, unsigned int _function_high) __attribute__ ((noreturn));
+extern "C" void M2RTS_ErrorMessage (const char *message_, unsigned int _message_high, const char *filename_, unsigned int _filename_high, unsigned int line, const char *function_, unsigned int _function_high) __attribute__ ((noreturn));
 extern "C" unsigned int M2RTS_Length (const char *a_, unsigned int _a_high);
 extern "C" void M2RTS_AssignmentException (void * filename, unsigned int line, unsigned int column, void * scope, void * message);
 extern "C" void M2RTS_ReturnException (void * filename, unsigned int line, unsigned int column, void * scope, void * message);
@@ -6678,7 +6679,7 @@ static decl_node newNode (decl_nodeT k)
       d->at.firstUsed = 0;
       return d;
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
   __builtin_unreachable ();
 }
 
@@ -7038,7 +7039,7 @@ static decl_node addToScope (decl_node n)
     }
   M2RTS_HALT (-1);
   __builtin_unreachable ();
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
   __builtin_unreachable ();
 }
 
@@ -7116,7 +7117,7 @@ static void setUnary (decl_node u, decl_nodeT k, decl_node a, decl_node t)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
 }
@@ -7399,7 +7400,7 @@ static void putFieldVarient (decl_node f, decl_node v)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
   switch (f->kind)
@@ -7410,7 +7411,7 @@ static void putFieldVarient (decl_node f, decl_node v)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
 }
@@ -7437,7 +7438,7 @@ static decl_node putFieldRecord (decl_node r, nameKey_Name tag, decl_node type,
         if (tag != nameKey_NulName)
           {
             /* avoid gcc warning by using compound statement even if not strictly necessary.  */
-            if ((symbolKey_getSymKey (r->recordF.localSymbols, tag)) == nameKey_NulName)
+            if ((symbolKey_getSymKey (r->recordF.localSymbols, tag)) == symbolKey_NulKey)
               {
                 symbolKey_putSymKey (r->recordF.localSymbols, tag, reinterpret_cast<void *> (n));
               }
@@ -7461,7 +7462,7 @@ static decl_node putFieldRecord (decl_node r, nameKey_Name tag, decl_node type,
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
   /* fill in, n.  */
@@ -7519,7 +7520,7 @@ static void putVarientTag (decl_node v, decl_node tag)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
 }
@@ -7543,7 +7544,7 @@ static decl_node getParent (decl_node n)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
   /* static analysis guarentees a RETURN statement will be used before here.  */
@@ -7571,7 +7572,7 @@ static decl_node getRecord (decl_node n)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
   /* static analysis guarentees a RETURN statement will be used before here.  */
@@ -7751,7 +7752,7 @@ static unsigned int getConstExpComplete (decl_node n)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
   /* static analysis guarentees a RETURN statement will be used before here.  */
@@ -7856,7 +7857,7 @@ static decl_node makeVal (decl_node params)
       M2RTS_HALT (-1);
       __builtin_unreachable ();
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
   __builtin_unreachable ();
 }
 
@@ -7877,7 +7878,7 @@ static decl_node makeCast (decl_node c, decl_node p)
       M2RTS_HALT (-1);
       __builtin_unreachable ();
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
   __builtin_unreachable ();
 }
 
@@ -8387,7 +8388,7 @@ static decl_node makeUnary (decl_nodeT k, decl_node e, decl_node res)
 
 
           default:
-            CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+            CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
             __builtin_unreachable ();
         }
     }
@@ -8481,7 +8482,7 @@ static DynamicStrings_String getStringContents (decl_node n)
     }
   M2RTS_HALT (-1);
   __builtin_unreachable ();
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
   __builtin_unreachable ();
 }
 
@@ -8617,7 +8618,7 @@ static decl_node doMakeBinary (decl_nodeT k, decl_node l, decl_node r, decl_node
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
   return n;
@@ -9217,12 +9218,12 @@ static decl_node doGetExprType (decl_node n)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
   M2RTS_HALT (-1);
   __builtin_unreachable ();
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
   __builtin_unreachable ();
 }
 
@@ -9361,12 +9362,12 @@ static decl_node getSymScope (decl_node n)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
   M2RTS_HALT (-1);
   __builtin_unreachable ();
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
   __builtin_unreachable ();
 }
 
@@ -9678,7 +9679,7 @@ static unsigned int needsParen (decl_node n)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
   return TRUE;
@@ -9787,7 +9788,7 @@ static void doPolyBinary (mcPretty_pretty p, decl_nodeT op, decl_node left, decl
 
 
           default:
-            CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+            CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
             __builtin_unreachable ();
         }
     }
@@ -9813,7 +9814,7 @@ static void doPolyBinary (mcPretty_pretty p, decl_nodeT op, decl_node left, decl
 
 
           default:
-            CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+            CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
             __builtin_unreachable ();
         }
     }
@@ -10091,7 +10092,7 @@ static decl_node doGetLastOp (decl_node a, decl_node b)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
   /* static analysis guarentees a RETURN statement will be used before here.  */
@@ -10731,7 +10732,7 @@ static void doExprC (mcPretty_pretty p, decl_node n)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
 }
@@ -10936,7 +10937,7 @@ static void doExprM2 (mcPretty_pretty p, decl_node n)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
 }
@@ -11108,7 +11109,7 @@ static DynamicStrings_String replaceChar (DynamicStrings_String s, char ch, cons
         return s;
       }
   }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
   __builtin_unreachable ();
 }
 
@@ -11168,7 +11169,7 @@ static unsigned int countChar (DynamicStrings_String s, char ch)
         return c;
       }
   }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
   __builtin_unreachable ();
 }
 
@@ -12227,7 +12228,7 @@ static decl_node doMin (decl_node n)
       M2RTS_HALT (-1);  /* finish the cacading elsif statement.  */
       __builtin_unreachable ();
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
   __builtin_unreachable ();
 }
 
@@ -12308,7 +12309,7 @@ static decl_node doMax (decl_node n)
       M2RTS_HALT (-1);  /* finish the cacading elsif statement.  */
       __builtin_unreachable ();
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
   __builtin_unreachable ();
 }
 
@@ -12597,7 +12598,7 @@ static void doBaseC (mcPretty_pretty p, decl_node n)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
   mcPretty_setNeedSpace (p);
@@ -12687,7 +12688,7 @@ static void doSystemC (mcPretty_pretty p, decl_node n)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
 }
@@ -16041,7 +16042,7 @@ static void doCreal (mcPretty_pretty p, decl_node t)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
 }
@@ -16072,7 +16073,7 @@ static void doCimag (mcPretty_pretty p, decl_node t)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
 }
@@ -16203,7 +16204,7 @@ static void doIntrinsicC (mcPretty_pretty p, decl_node n)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
   outText (p, (const char *) ";", 1);
@@ -17365,7 +17366,7 @@ static void dbs (decl_dependentState s, decl_node n)
 
 
           default:
-            CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+            CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
             __builtin_unreachable ();
         }
       if (n != NULL)
@@ -18258,10 +18259,10 @@ static decl_dependentState doDependants (alists_alist l, decl_node n)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
   __builtin_unreachable ();
 }
 
@@ -18358,7 +18359,7 @@ static void visitIntrinsicFunction (alists_alist v, decl_node n, decl_nodeProced
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
 }
@@ -19357,7 +19358,7 @@ static void visitDependants (alists_alist v, decl_node n, decl_nodeProcedure p)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
 }
@@ -19704,12 +19705,12 @@ static DynamicStrings_String genKind (decl_node n)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
   M2RTS_HALT (-1);
   __builtin_unreachable ();
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
   __builtin_unreachable ();
 }
 
@@ -20884,7 +20885,7 @@ static void doBaseM2 (mcPretty_pretty p, decl_node n)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
   mcPretty_setNeedSpace (p);
@@ -20910,7 +20911,7 @@ static void doSystemM2 (mcPretty_pretty p, decl_node n)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
 }
@@ -22121,10 +22122,10 @@ static decl_node doDupExpr (decl_node n)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
   __builtin_unreachable ();
 }
 
@@ -22454,7 +22455,7 @@ extern "C" unsigned int decl_isVisited (decl_node n)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
   /* static analysis guarentees a RETURN statement will be used before here.  */
@@ -22484,7 +22485,7 @@ extern "C" void decl_unsetVisited (decl_node n)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
 }
@@ -22512,7 +22513,7 @@ extern "C" void decl_setVisited (decl_node n)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
 }
@@ -22540,7 +22541,7 @@ extern "C" void decl_setEnumsComplete (decl_node n)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
 }
@@ -22568,7 +22569,7 @@ extern "C" unsigned int decl_getEnumsComplete (decl_node n)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
   /* static analysis guarentees a RETURN statement will be used before here.  */
@@ -22789,7 +22790,7 @@ extern "C" decl_node decl_lookupInScope (decl_node scope, nameKey_Name n)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
   /* static analysis guarentees a RETURN statement will be used before here.  */
@@ -23164,12 +23165,12 @@ extern "C" decl_node decl_getType (decl_node n)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
   M2RTS_HALT (-1);
   __builtin_unreachable ();
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
   __builtin_unreachable ();
 }
 
@@ -23563,7 +23564,7 @@ extern "C" decl_node decl_getScope (decl_node n)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
   /* static analysis guarentees a RETURN statement will be used before here.  */
@@ -24218,7 +24219,7 @@ extern "C" decl_node decl_makeVarient (decl_node r)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
   return n;
@@ -24685,7 +24686,7 @@ extern "C" nameKey_Name decl_getSymName (decl_node n)
         __builtin_unreachable ();
         break;
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
   __builtin_unreachable ();
 }
 
@@ -24723,7 +24724,7 @@ extern "C" decl_node decl_import (decl_node m, decl_node n)
 
 
           default:
-            CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+            CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
             __builtin_unreachable ();
         }
       importEnumFields (m, n);
@@ -24852,7 +24853,7 @@ extern "C" void decl_setSource (decl_node n, nameKey_Name s)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
 }
@@ -24880,7 +24881,7 @@ extern "C" nameKey_Name decl_getSource (decl_node n)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
   /* static analysis guarentees a RETURN statement will be used before here.  */
@@ -25323,7 +25324,7 @@ extern "C" void decl_addParameter (decl_node proc, decl_node param)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
 }
@@ -25416,7 +25417,7 @@ extern "C" decl_node decl_makeBinaryTok (mcReserved_toktype op, decl_node l, dec
       M2RTS_HALT (-1);  /* most likely op needs a clause as above.  */
       __builtin_unreachable ();
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
   __builtin_unreachable ();
 }
 
@@ -25448,7 +25449,7 @@ extern "C" decl_node decl_makeUnaryTok (mcReserved_toktype op, decl_node e)
       M2RTS_HALT (-1);  /* most likely op needs a clause as above.  */
       __builtin_unreachable ();
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
   __builtin_unreachable ();
 }
 
@@ -25886,7 +25887,7 @@ extern "C" void decl_setConstExpComplete (decl_node n)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
 }
@@ -26251,7 +26252,7 @@ extern "C" void decl_putBegin (decl_node b, decl_node s)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
 }
@@ -26278,7 +26279,7 @@ extern "C" void decl_putFinally (decl_node b, decl_node s)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
 }
@@ -26906,7 +26907,7 @@ extern "C" void decl_out (void)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/decl.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/decl.def", 20, 1);
         __builtin_unreachable ();
     }
   closeOutput ();
diff --git a/gcc/m2/mc-boot/Gkeyc.c b/gcc/m2/mc-boot/Gkeyc.c
index 1b2fb97..e000bfe 100644
--- a/gcc/m2/mc-boot/Gkeyc.c
+++ b/gcc/m2/mc-boot/Gkeyc.c
@@ -600,7 +600,7 @@ static void checkAbs (mcPretty_pretty p)
 
 static void checkLimits (mcPretty_pretty p)
 {
-  if ((((((((((((((seenMemcpy || seenIntMin) || seenUIntMin) || seenLongMin) || seenULongMin) || seenCharMin) || seenUCharMin) || seenUIntMin) || seenIntMax) || seenUIntMax) || seenLongMax) || seenULongMax) || seenCharMax) || seenUCharMax) || seenUIntMax)
+  if ((((((((((((seenMemcpy || seenIntMin) || seenUIntMin) || seenLongMin) || seenULongMin) || seenCharMin) || seenUCharMin) || seenIntMax) || seenUIntMax) || seenLongMax) || seenULongMax) || seenCharMax) || seenUCharMax)  /* OR seenUIntMax  */
     {
       checkGccConfigSystem (p);
       if (! (mcOptions_getGccConfigSystem ()))
@@ -908,7 +908,7 @@ static unsigned int mangleN (nameKey_Name n, DynamicStrings_String *m, unsigned
         return TRUE;
       }
   }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/mc/keyc.def", 20, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/mc/keyc.def", 20, 1);
   __builtin_unreachable ();
 }
 
@@ -1067,14 +1067,12 @@ static void init (void)
   seenULongMin = FALSE;
   seenCharMin = FALSE;
   seenUCharMin = FALSE;
-  seenUIntMin = FALSE;
   seenIntMax = FALSE;
   seenUIntMax = FALSE;
   seenLongMax = FALSE;
   seenULongMax = FALSE;
   seenCharMax = FALSE;
   seenUCharMax = FALSE;
-  seenUIntMax = FALSE;
   seenLabs = FALSE;
   seenAbs = FALSE;
   seenFabs = FALSE;
diff --git a/gcc/m2/mc-boot/GmcComment.c b/gcc/m2/mc-boot/GmcComment.c
index 88f5de0..4dfad51 100644
--- a/gcc/m2/mc-boot/GmcComment.c
+++ b/gcc/m2/mc-boot/GmcComment.c
@@ -257,7 +257,7 @@ static void dumpComment (mcComment_commentDesc cd)
 
 
       default:
-        CaseException ("../../gcc-git-devel-modula2/gcc/m2/mc/mcComment.def", 20, 1);
+        CaseException ("../../gcc-read-write/gcc/m2/mc/mcComment.def", 20, 1);
         __builtin_unreachable ();
     }
   if (cd->used)
diff --git a/gcc/m2/mc-boot/GmcComp.c b/gcc/m2/mc-boot/GmcComp.c
index d633e79..e6b4e35 100644
--- a/gcc/m2/mc-boot/GmcComp.c
+++ b/gcc/m2/mc-boot/GmcComp.c
@@ -294,7 +294,7 @@ static decl_node examineCompilationUnit (void)
     }
   mcflex_mcError (DynamicStrings_string (DynamicStrings_InitString ((const char *) "failed to find module name", 26)));
   libc_exit (1);
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/mc/mcComp.def", 20, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/mc/mcComp.def", 20, 1);
   __builtin_unreachable ();
 }
 
@@ -324,7 +324,7 @@ static decl_node peepInto (DynamicStrings_String s)
       mcPrintf_fprintf1 (FIO_StdErr, (const char *) "failed to open %s\\n", 19, (const unsigned char *) &s, (sizeof (s)-1));
       libc_exit (1);
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/mc/mcComp.def", 20, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/mc/mcComp.def", 20, 1);
   __builtin_unreachable ();
 }
 
diff --git a/gcc/m2/mc-boot/GmcDebug.c b/gcc/m2/mc-boot/GmcDebug.c
index 3c47196..8cac40e 100644
--- a/gcc/m2/mc-boot/GmcDebug.c
+++ b/gcc/m2/mc-boot/GmcDebug.c
@@ -54,7 +54,7 @@ extern "C" void mcDebug_assert (unsigned int q)
 {
   if (! q)
     {
-      mcError_internalError ((const char *) "assert failed", 13, (const char *) "../../gcc-git-devel-modula2/gcc/m2/mc/mcDebug.mod", 49, 35);
+      mcError_internalError ((const char *) "assert failed", 13, (const char *) "../../gcc-read-write/gcc/m2/mc/mcDebug.mod", 42, 35);
     }
 }
 
diff --git a/gcc/m2/mc-boot/GmcMetaError.c b/gcc/m2/mc-boot/GmcMetaError.c
index 0c4aaf9..3073e62 100644
--- a/gcc/m2/mc-boot/GmcMetaError.c
+++ b/gcc/m2/mc-boot/GmcMetaError.c
@@ -408,7 +408,7 @@ static void internalFormat (DynamicStrings_String s, int i, const char *m_, unsi
   s = DynamicStrings_ConCatChar (s, '^');
   s = SFIO_WriteS (FIO_StdOut, s);
   FIO_WriteLine (FIO_StdOut);
-  mcError_internalError ((const char *) m, _m_high, (const char *) "../../gcc-git-devel-modula2/gcc/m2/mc/mcMetaError.mod", 53, 97);
+  mcError_internalError ((const char *) m, _m_high, (const char *) "../../gcc-read-write/gcc/m2/mc/mcMetaError.mod", 46, 97);
 }
 
 
@@ -420,7 +420,7 @@ static DynamicStrings_String x (DynamicStrings_String a, DynamicStrings_String b
 {
   if (a != b)
     {
-      mcError_internalError ((const char *) "different string returned", 25, (const char *) "../../gcc-git-devel-modula2/gcc/m2/mc/mcMetaError.mod", 53, 109);
+      mcError_internalError ((const char *) "different string returned", 25, (const char *) "../../gcc-read-write/gcc/m2/mc/mcMetaError.mod", 46, 109);
     }
   return a;
   /* static analysis guarentees a RETURN statement will be used before here.  */
@@ -734,7 +734,7 @@ static mcError_error doError (mcError_error e, mcMetaError_errorType t, unsigned
       case mcMetaError_chained:
         if (e == NULL)
           {
-            mcError_internalError ((const char *) "should not be chaining an error onto an empty error note", 56, (const char *) "../../gcc-git-devel-modula2/gcc/m2/mc/mcMetaError.mod", 53, 355);
+            mcError_internalError ((const char *) "should not be chaining an error onto an empty error note", 56, (const char *) "../../gcc-read-write/gcc/m2/mc/mcMetaError.mod", 46, 355);
           }
         else
           {
@@ -758,7 +758,7 @@ static mcError_error doError (mcError_error e, mcMetaError_errorType t, unsigned
 
 
       default:
-        mcError_internalError ((const char *) "unexpected enumeration value", 28, (const char *) "../../gcc-git-devel-modula2/gcc/m2/mc/mcMetaError.mod", 53, 369);
+        mcError_internalError ((const char *) "unexpected enumeration value", 28, (const char *) "../../gcc-read-write/gcc/m2/mc/mcMetaError.mod", 46, 369);
         break;
     }
   return e;
diff --git a/gcc/m2/mc-boot/GmcOptions.c b/gcc/m2/mc-boot/GmcOptions.c
index 42717cf..77801c0 100644
--- a/gcc/m2/mc-boot/GmcOptions.c
+++ b/gcc/m2/mc-boot/GmcOptions.c
@@ -50,7 +50,6 @@ Boston, MA 02110-1301, USA.  */
 #   include "GFIO.h"
 #   include "GSFIO.h"
 
-#   define YEAR "2021"
 static unsigned int langC;
 static unsigned int langCPP;
 static unsigned int langM2;
@@ -172,6 +171,12 @@ extern "C" unsigned int mcOptions_getScaffoldMain (void);
 extern "C" void mcOptions_writeGPLheader (FIO_File f);
 
 /*
+   getYear - return the year.
+*/
+
+static unsigned int getYear (void);
+
+/*
    displayVersion - displays the version of the compiler.
 */
 
@@ -294,13 +299,36 @@ static void handleOption (DynamicStrings_String arg);
 
 
 /*
+   getYear - return the year.
+*/
+
+static unsigned int getYear (void)
+{
+  libc_time_t epoch;
+  libc_ptrToTM localTime;
+
+  epoch = libc_time (NULL);
+  localTime = static_cast<libc_ptrToTM> (libc_localtime (&epoch));
+  return localTime->tm_year+1900;
+  /* static analysis guarentees a RETURN statement will be used before here.  */
+  __builtin_unreachable ();
+}
+
+
+/*
    displayVersion - displays the version of the compiler.
 */
 
 static void displayVersion (unsigned int mustExit)
 {
-  mcPrintf_printf0 ((const char *) "Copyright (C) ''2021'' Free Software Foundation, Inc.\\n", 55);
-  mcPrintf_printf0 ((const char *) "License GPLv2: GNU GPL version 2 or later <http://gnu.org/licenses/gpl.html>\\n", 78);
+  unsigned int year;
+
+  year = getYear ();
+  /* These first three calls to printf hide the first line of text away from the year change script.  */
+  mcPrintf_printf0 ((const char *) "Copyright ", 10);
+  mcPrintf_printf0 ((const char *) "(C)", 3);  /* A unicode char here would be good.  */
+  mcPrintf_printf1 ((const char *) " %d Free Software Foundation, Inc.\\n", 36, (const unsigned char *) &year, (sizeof (year)-1));  /* A unicode char here would be good.  */
+  mcPrintf_printf0 ((const char *) "License GPLv3: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>\\n", 78);
   mcPrintf_printf0 ((const char *) "This is free software: you are free to change and redistribute it.\\n", 68);
   mcPrintf_printf0 ((const char *) "There is NO WARRANTY, to the extent permitted by law.\\n", 55);
   if (mustExit)
@@ -424,7 +452,10 @@ static void commentS (FIO_File f, DynamicStrings_String s)
 
 static void gplBody (FIO_File f)
 {
-  comment (f, (const char *) "Copyright (C) ''2021'' Free Software Foundation, Inc.", 53);
+  unsigned int year;
+
+  year = getYear ();
+  mcPrintf_printf1 ((const char *) "Copyright (C) %d Free Software Foundation, Inc.\\n", 49, (const unsigned char *) &year, (sizeof (year)-1));
   if (contributed)
     {
       FIO_WriteString (f, (const char *) "Contributed by ", 15);
@@ -464,7 +495,10 @@ static void gplBody (FIO_File f)
 
 static void glplBody (FIO_File f)
 {
-  comment (f, (const char *) "Copyright (C) ''2021'' Free Software Foundation, Inc.", 53);
+  unsigned int year;
+
+  year = getYear ();
+  mcPrintf_printf1 ((const char *) "Copyright (C) %d Free Software Foundation, Inc.\\n", 49, (const unsigned char *) &year, (sizeof (year)-1));
   if (contributed)
     {
       FIO_WriteString (f, (const char *) "Contributed by ", 15);
diff --git a/gcc/m2/mc-boot/GmcStack.c b/gcc/m2/mc-boot/GmcStack.c
index 83fecda..a1f13d8 100644
--- a/gcc/m2/mc-boot/GmcStack.c
+++ b/gcc/m2/mc-boot/GmcStack.c
@@ -165,7 +165,7 @@ extern "C" void * mcStack_pop (mcStack_stack s)
       Indexing_DeleteIndice (s->list, Indexing_HighIndice (s->list));
       return a;
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/mc/mcStack.def", 20, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/mc/mcStack.def", 20, 1);
   __builtin_unreachable ();
 }
 
@@ -215,7 +215,7 @@ extern "C" void * mcStack_access (mcStack_stack s, unsigned int i)
     {
       return Indexing_GetIndice (s->list, i);
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/mc/mcStack.def", 20, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/mc/mcStack.def", 20, 1);
   __builtin_unreachable ();
 }
 
diff --git a/gcc/m2/mc-boot/GnameKey.c b/gcc/m2/mc-boot/GnameKey.c
index 22eac97..11cb6fa 100644
--- a/gcc/m2/mc-boot/GnameKey.c
+++ b/gcc/m2/mc-boot/GnameKey.c
@@ -323,7 +323,7 @@ extern "C" nameKey_Name nameKey_makeKey (const char *a_, unsigned int _a_high)
       (*p) = ASCII_nul;
       return doMakeKey (n, higha);
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/mc/nameKey.def", 20, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/mc/nameKey.def", 20, 1);
   __builtin_unreachable ();
 }
 
@@ -373,7 +373,7 @@ extern "C" nameKey_Name nameKey_makekey (void * a)
           return doMakeKey (n, higha);
         }
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/mc/nameKey.def", 20, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/mc/nameKey.def", 20, 1);
   __builtin_unreachable ();
 }
 
diff --git a/gcc/m2/mc-boot/GsymbolKey.c b/gcc/m2/mc-boot/GsymbolKey.c
index 2f3295b..e72133e 100644
--- a/gcc/m2/mc-boot/GsymbolKey.c
+++ b/gcc/m2/mc-boot/GsymbolKey.c
@@ -142,7 +142,7 @@ static void findNodeAndParentInTree (symbolKey_symbolTree t, nameKey_Name n, sym
   (*father) = t;
   if (t == NULL)
     {
-      Debug_Halt ((const char *) "parameter t should never be NIL", 31, 203, (const char *) "../../gcc-git-devel-modula2/gcc/m2/mc/symbolKey.mod", 51);
+      Debug_Halt ((const char *) "parameter t should never be NIL", 31, 203, (const char *) "../../gcc-read-write/gcc/m2/mc/symbolKey.mod", 44);
     }
   (*child) = t->left;
   if ((*child) != NULL)
@@ -285,7 +285,7 @@ extern "C" void symbolKey_putSymKey (symbolKey_symbolTree t, nameKey_Name name,
     }
   else
     {
-      Debug_Halt ((const char *) "symbol already stored", 21, 119, (const char *) "../../gcc-git-devel-modula2/gcc/m2/mc/symbolKey.mod", 51);
+      Debug_Halt ((const char *) "symbol already stored", 21, 119, (const char *) "../../gcc-read-write/gcc/m2/mc/symbolKey.mod", 44);
     }
 }
 
@@ -352,7 +352,7 @@ extern "C" void symbolKey_delSymKey (symbolKey_symbolTree t, nameKey_Name name)
     }
   else
     {
-      Debug_Halt ((const char *) "trying to delete a symbol that is not in the tree - the compiler never expects this to occur", 92, 186, (const char *) "../../gcc-git-devel-modula2/gcc/m2/mc/symbolKey.mod", 51);
+      Debug_Halt ((const char *) "trying to delete a symbol that is not in the tree - the compiler never expects this to occur", 92, 186, (const char *) "../../gcc-read-write/gcc/m2/mc/symbolKey.mod", 44);
     }
 }
 
diff --git a/gcc/m2/mc/decl.mod b/gcc/m2/mc/decl.mod
index 738f66f..f6afd66 100644
--- a/gcc/m2/mc/decl.mod
+++ b/gcc/m2/mc/decl.mod
@@ -22,7 +22,7 @@ along with GNU Modula-2; see the file COPYING3.  If not see
 IMPLEMENTATION MODULE decl ; (*!m2pim*)
 
 FROM ASCII IMPORT lf, tab ;
-FROM symbolKey IMPORT symbolTree, initTree, getSymKey, putSymKey, foreachNodeDo ;
+FROM symbolKey IMPORT NulKey, symbolTree, initTree, getSymKey, putSymKey, foreachNodeDo ;
 FROM mcDebug IMPORT assert ;
 FROM Storage IMPORT ALLOCATE, DEALLOCATE ;
 FROM nameKey IMPORT NulName, makeKey, lengthKey, makekey, keyToCharStar ;
@@ -2936,7 +2936,7 @@ BEGIN
                (* ensure that field, n, is in the parents Local Symbols.  *)
                IF tag#NulName
                THEN
-                  IF getSymKey (recordF.localSymbols, tag) = NulName
+                  IF getSymKey (recordF.localSymbols, tag) = NulKey
                   THEN
                      putSymKey (recordF.localSymbols, tag, n)
                   ELSE
diff --git a/gcc/m2/mc/keyc.mod b/gcc/m2/mc/keyc.mod
index 5e1016d..a57103b 100644
--- a/gcc/m2/mc/keyc.mod
+++ b/gcc/m2/mc/keyc.mod
@@ -457,9 +457,9 @@ PROCEDURE checkLimits (p: pretty) ;
 BEGIN
    IF seenMemcpy OR seenIntMin OR seenUIntMin OR
       seenLongMin OR seenULongMin OR seenCharMin OR
-      seenUCharMin OR seenUIntMin OR seenIntMax OR
+      seenUCharMin OR (* seenUIntMin OR *) seenIntMax OR
       seenUIntMax OR seenLongMax OR seenULongMax OR
-      seenCharMax OR seenUCharMax OR seenUIntMax
+      seenCharMax OR seenUCharMax (* OR seenUIntMax *)
    THEN
       checkGccConfigSystem (p);
       IF NOT getGccConfigSystem ()
@@ -1118,14 +1118,12 @@ BEGIN
    seenULongMin := FALSE ;
    seenCharMin := FALSE ;
    seenUCharMin := FALSE ;
-   seenUIntMin := FALSE ;
    seenIntMax := FALSE ;
    seenUIntMax := FALSE ;
    seenLongMax := FALSE ;
    seenULongMax := FALSE ;
    seenCharMax := FALSE ;
    seenUCharMax := FALSE ;
-   seenUIntMax := FALSE ;
    seenLabs := FALSE ;
    seenAbs := FALSE ;
    seenFabs := FALSE ;
diff --git a/gcc/m2/mc/mcOptions.mod b/gcc/m2/mc/mcOptions.mod
index 104edd3..909d798 100644
--- a/gcc/m2/mc/mcOptions.mod
+++ b/gcc/m2/mc/mcOptions.mod
@@ -20,8 +20,8 @@ IMPLEMENTATION MODULE mcOptions ;
 
 FROM SArgs IMPORT GetArg, Narg ;
 FROM mcSearch IMPORT prependSearchPath ;
-FROM libc IMPORT exit, printf ;
-FROM mcPrintf IMPORT printf0 ;
+FROM libc IMPORT exit, printf, time, localtime, time_t, ptrToTM ;
+FROM mcPrintf IMPORT printf0, printf1 ;
 FROM Debug IMPORT Halt ;
 FROM StrLib IMPORT StrLen ;
 FROM decl IMPORT setLangC, setLangCP, setLangM2 ;
@@ -33,9 +33,6 @@ FROM DynamicStrings IMPORT String, Length, InitString, Mark, Slice, EqualArray,
 IMPORT FIO ;
 IMPORT SFIO ;
 
-CONST
-   YEAR = '2021' ;
-
 VAR
    langC,
    langCPP,
@@ -65,14 +62,36 @@ VAR
    cppProgram       : String ;
 
 
+
+(*
+   getYear - return the year.
+*)
+
+PROCEDURE getYear () : CARDINAL ;
+VAR
+   epoch    : time_t ;
+   localTime: ptrToTM ;
+BEGIN
+   epoch := time (NIL) ;
+   localTime := localtime (epoch) ;
+   RETURN localTime^.tm_year + 1900
+END getYear ;
+
+
 (*
    displayVersion - displays the version of the compiler.
 *)
 
 PROCEDURE displayVersion (mustExit: BOOLEAN) ;
-BEGIN
-   printf0 ('Copyright (C) ' + YEAR + ' Free Software Foundation, Inc.\n') ;
-   printf0 ('License GPLv2: GNU GPL version 2 or later <http://gnu.org/licenses/gpl.html>\n') ;
+VAR
+   year: CARDINAL ;
+BEGIN
+   year := getYear () ;
+   (* These first three calls to printf hide the first line of text away from the year change script.  *)
+   printf0 ('Copyright ') ;
+   printf0 ('(C)') ;  (* A unicode char here would be good.  *)
+   printf1 (' %d Free Software Foundation, Inc.\n', year) ;
+   printf0 ('License GPLv3: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>\n') ;
    printf0 ('This is free software: you are free to change and redistribute it.\n') ;
    printf0 ('There is NO WARRANTY, to the extent permitted by law.\n') ;
    IF mustExit
@@ -183,8 +202,11 @@ END commentS ;
 *)
 
 PROCEDURE gplBody (f: File) ;
+VAR
+   year: CARDINAL ;
 BEGIN
-   comment (f, 'Copyright (C) ' + YEAR + ' Free Software Foundation, Inc.') ;
+   year := getYear () ;
+   printf1 ('Copyright (C) %d Free Software Foundation, Inc.\n', year) ;
    IF contributed
    THEN
       FIO.WriteString (f, "Contributed by ") ;
@@ -222,8 +244,11 @@ END gplBody ;
 *)
 
 PROCEDURE glplBody (f: File) ;
+VAR
+   year: CARDINAL ;
 BEGIN
-   comment (f, 'Copyright (C) ' + YEAR + ' Free Software Foundation, Inc.') ;
+   year := getYear () ;
+   printf1 ('Copyright (C) %d Free Software Foundation, Inc.\n', year) ;
    IF contributed
    THEN
       FIO.WriteString (f, "Contributed by ") ;
diff --git a/gcc/m2/pge-boot/GArgs.c b/gcc/m2/pge-boot/GArgs.c
index 3c3f95b..69fbdd0 100644
--- a/gcc/m2/pge-boot/GArgs.c
+++ b/gcc/m2/pge-boot/GArgs.c
@@ -81,7 +81,7 @@ extern "C" unsigned int Args_GetArg (char *a, unsigned int _a_high, unsigned int
   if (i < (UnixArgs_GetArgC ()))
     {
       Source = static_cast<Args__T1> (UnixArgs_GetArgV ());
-      while (((*(*Source).array[i]).array[j] != ASCII_nul) && (j < High))
+      while ((j < High) && ((*(*Source).array[i]).array[j] != ASCII_nul))
         {
           a[j] = (*(*Source).array[i]).array[j];
           j += 1;
diff --git a/gcc/m2/pge-boot/GDynamicStrings.c b/gcc/m2/pge-boot/GDynamicStrings.c
index e6dea00..7507eca 100644
--- a/gcc/m2/pge-boot/GDynamicStrings.c
+++ b/gcc/m2/pge-boot/GDynamicStrings.c
@@ -1217,7 +1217,7 @@ static void ConcatContents (DynamicStrings_Contents *c, const char *a_, unsigned
       (*c).next->contents.next = NULL;
       ConcatContents (&(*c).next->contents, (const char *) a, _a_high, h, o);
       AddDebugInfo ((*c).next);
-      (*c).next = AssignDebug ((*c).next, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/DynamicStrings.mod", 62, 722, (const char *) "ConcatContents", 14);
+      (*c).next = AssignDebug ((*c).next, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/DynamicStrings.mod", 55, 722, (const char *) "ConcatContents", 14);
     }
   else
     {
@@ -1315,7 +1315,7 @@ static void ConcatContentsAddress (DynamicStrings_Contents *c, void * a, unsigne
       AddDebugInfo ((*c).next);
       if (TraceOn)
         {
-          (*c).next = AssignDebug ((*c).next, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/DynamicStrings.mod", 62, 917, (const char *) "ConcatContentsAddress", 21);
+          (*c).next = AssignDebug ((*c).next, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/DynamicStrings.mod", 55, 917, (const char *) "ConcatContentsAddress", 21);
         }
     }
   else
@@ -1540,7 +1540,7 @@ extern "C" DynamicStrings_String DynamicStrings_InitString (const char *a_, unsi
   AddDebugInfo (s);
   if (TraceOn)
     {
-      s = AssignDebug (s, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/DynamicStrings.mod", 62, 758, (const char *) "InitString", 10);
+      s = AssignDebug (s, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/DynamicStrings.mod", 55, 758, (const char *) "InitString", 10);
     }
   return s;
   /* static analysis guarentees a RETURN statement will be used before here.  */
@@ -1643,7 +1643,7 @@ extern "C" DynamicStrings_String DynamicStrings_InitStringCharStar (void * a)
   AddDebugInfo (s);
   if (TraceOn)
     {
-      s = AssignDebug (s, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/DynamicStrings.mod", 62, 957, (const char *) "InitStringCharStar", 18);
+      s = AssignDebug (s, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/DynamicStrings.mod", 55, 957, (const char *) "InitStringCharStar", 18);
     }
   return s;
   /* static analysis guarentees a RETURN statement will be used before here.  */
@@ -1668,7 +1668,7 @@ extern "C" DynamicStrings_String DynamicStrings_InitStringChar (char ch)
   s = DynamicStrings_InitString ((const char *) &a.array[0], 1);
   if (TraceOn)
     {
-      s = AssignDebug (s, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/DynamicStrings.mod", 62, 977, (const char *) "InitStringChar", 14);
+      s = AssignDebug (s, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/DynamicStrings.mod", 55, 977, (const char *) "InitStringChar", 14);
     }
   return s;
   /* static analysis guarentees a RETURN statement will be used before here.  */
@@ -1826,7 +1826,7 @@ extern "C" DynamicStrings_String DynamicStrings_Dup (DynamicStrings_String s)
   s = DynamicStrings_Assign (DynamicStrings_InitString ((const char *) "", 0), s);
   if (TraceOn)
     {
-      s = AssignDebug (s, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/DynamicStrings.mod", 62, 1173, (const char *) "Dup", 3);
+      s = AssignDebug (s, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/DynamicStrings.mod", 55, 1173, (const char *) "Dup", 3);
     }
   return s;
   /* static analysis guarentees a RETURN statement will be used before here.  */
@@ -1848,7 +1848,7 @@ extern "C" DynamicStrings_String DynamicStrings_Add (DynamicStrings_String a, Dy
   a = DynamicStrings_ConCat (DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "", 0), a), b);
   if (TraceOn)
     {
-      a = AssignDebug (a, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/DynamicStrings.mod", 62, 1193, (const char *) "Add", 3);
+      a = AssignDebug (a, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/DynamicStrings.mod", 55, 1193, (const char *) "Add", 3);
     }
   return a;
   /* static analysis guarentees a RETURN statement will be used before here.  */
@@ -1877,16 +1877,6 @@ extern "C" unsigned int DynamicStrings_Equal (DynamicStrings_String a, DynamicSt
           Assertion_Assert (a->contents.len == b->contents.len);
           while (i < a->contents.len)
             {
-              if (a->contents.buf.array[i] != a->contents.buf.array[i])
-                {
-                  M2RTS_HALT (-1);
-                  __builtin_unreachable ();
-                }
-              if (b->contents.buf.array[i] != b->contents.buf.array[i])
-                {
-                  M2RTS_HALT (-1);
-                  __builtin_unreachable ();
-                }
               if (a->contents.buf.array[i] != b->contents.buf.array[i])
                 {
                   return FALSE;
@@ -1923,7 +1913,7 @@ extern "C" unsigned int DynamicStrings_EqualCharStar (DynamicStrings_String s, v
   t = DynamicStrings_InitStringCharStar (a);
   if (TraceOn)
     {
-      t = AssignDebug (t, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/DynamicStrings.mod", 62, 1258, (const char *) "EqualCharStar", 13);
+      t = AssignDebug (t, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/DynamicStrings.mod", 55, 1250, (const char *) "EqualCharStar", 13);
     }
   t = AddToGarbage (t, s);
   if (DynamicStrings_Equal (t, s))
@@ -1961,7 +1951,7 @@ extern "C" unsigned int DynamicStrings_EqualArray (DynamicStrings_String s, cons
   t = DynamicStrings_InitString ((const char *) a, _a_high);
   if (TraceOn)
     {
-      t = AssignDebug (t, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/DynamicStrings.mod", 62, 1288, (const char *) "EqualArray", 10);
+      t = AssignDebug (t, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/DynamicStrings.mod", 55, 1280, (const char *) "EqualArray", 10);
     }
   t = AddToGarbage (t, s);
   if (DynamicStrings_Equal (t, s))
@@ -1999,7 +1989,7 @@ extern "C" DynamicStrings_String DynamicStrings_Mult (DynamicStrings_String s, u
     }
   if (TraceOn)
     {
-      s = AssignDebug (s, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/DynamicStrings.mod", 62, 1320, (const char *) "Mult", 4);
+      s = AssignDebug (s, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/DynamicStrings.mod", 55, 1312, (const char *) "Mult", 4);
     }
   return s;
   /* static analysis guarentees a RETURN statement will be used before here.  */
@@ -2078,7 +2068,7 @@ extern "C" DynamicStrings_String DynamicStrings_Slice (DynamicStrings_String s,
                       AddDebugInfo (t->contents.next);
                       if (TraceOn)
                         {
-                          t->contents.next = AssignDebug (t->contents.next, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/DynamicStrings.mod", 62, 1388, (const char *) "Slice", 5);
+                          t->contents.next = AssignDebug (t->contents.next, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/DynamicStrings.mod", 55, 1380, (const char *) "Slice", 5);
                         }
                     }
                   t = t->contents.next;
@@ -2096,7 +2086,7 @@ extern "C" DynamicStrings_String DynamicStrings_Slice (DynamicStrings_String s,
     }
   if (TraceOn)
     {
-      d = AssignDebug (d, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/DynamicStrings.mod", 62, 1405, (const char *) "Slice", 5);
+      d = AssignDebug (d, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/DynamicStrings.mod", 55, 1397, (const char *) "Slice", 5);
     }
   return d;
   /* static analysis guarentees a RETURN statement will be used before here.  */
@@ -2224,7 +2214,7 @@ extern "C" DynamicStrings_String DynamicStrings_RemoveComment (DynamicStrings_St
     }
   if (TraceOn)
     {
-      s = AssignDebug (s, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/DynamicStrings.mod", 62, 1517, (const char *) "RemoveComment", 13);
+      s = AssignDebug (s, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/DynamicStrings.mod", 55, 1509, (const char *) "RemoveComment", 13);
     }
   return s;
   /* static analysis guarentees a RETURN statement will be used before here.  */
@@ -2249,7 +2239,7 @@ extern "C" DynamicStrings_String DynamicStrings_RemoveWhitePrefix (DynamicString
   s = DynamicStrings_Slice (s, (int ) (i), 0);
   if (TraceOn)
     {
-      s = AssignDebug (s, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/DynamicStrings.mod", 62, 1629, (const char *) "RemoveWhitePrefix", 17);
+      s = AssignDebug (s, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/DynamicStrings.mod", 55, 1621, (const char *) "RemoveWhitePrefix", 17);
     }
   return s;
   /* static analysis guarentees a RETURN statement will be used before here.  */
@@ -2274,7 +2264,7 @@ extern "C" DynamicStrings_String DynamicStrings_RemoveWhitePostfix (DynamicStrin
   s = DynamicStrings_Slice (s, 0, i+1);
   if (TraceOn)
     {
-      s = AssignDebug (s, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/DynamicStrings.mod", 62, 1651, (const char *) "RemoveWhitePostfix", 18);
+      s = AssignDebug (s, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/DynamicStrings.mod", 55, 1643, (const char *) "RemoveWhitePostfix", 18);
     }
   return s;
   /* static analysis guarentees a RETURN statement will be used before here.  */
@@ -2643,7 +2633,7 @@ extern "C" DynamicStrings_String DynamicStrings_PopAllocationExemption (unsigned
         {
           stop ();
           /* writeString ("mismatched number of PopAllocation's compared to PushAllocation's")  */
-          M2RTS_Halt ((const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/DynamicStrings.mod", 62, 176, (const char *) "PopAllocationExemption", 22, (const char *) "mismatched number of PopAllocation's compared to PushAllocation's", 65);
+          M2RTS_Halt ((const char *) "../../gcc-read-write/gcc/m2/gm2-libs/DynamicStrings.mod", 55, 176, (const char *) "PopAllocationExemption", 22, (const char *) "mismatched number of PopAllocation's compared to PushAllocation's", 65);
         }
       else
         {
diff --git a/gcc/m2/pge-boot/GFIO.c b/gcc/m2/pge-boot/GFIO.c
index 7c2164e..adcbae3 100644
--- a/gcc/m2/pge-boot/GFIO.c
+++ b/gcc/m2/pge-boot/GFIO.c
@@ -558,7 +558,7 @@ static FIO_File GetNextFreeDescriptor (void)
         return f;  /* create new slot  */
       }
   }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/FIO.def", 25, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/gm2-libs/FIO.def", 25, 1);
   __builtin_unreachable ();
 }
 
@@ -2269,7 +2269,7 @@ extern "C" void * FIO_getFileName (FIO_File f)
           return fd->name.address;
         }
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/FIO.def", 25, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/gm2-libs/FIO.def", 25, 1);
   __builtin_unreachable ();
 }
 
@@ -2296,7 +2296,7 @@ extern "C" unsigned int FIO_getFileNameLength (FIO_File f)
           return fd->name.size;
         }
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/FIO.def", 25, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/gm2-libs/FIO.def", 25, 1);
   __builtin_unreachable ();
 }
 
diff --git a/gcc/m2/pge-boot/GIndexing.c b/gcc/m2/pge-boot/GIndexing.c
index 71d3432..81c66fc 100644
--- a/gcc/m2/pge-boot/GIndexing.c
+++ b/gcc/m2/pge-boot/GIndexing.c
@@ -227,7 +227,7 @@ extern "C" unsigned int Indexing_InBounds (Indexing_Index i, unsigned int n)
     {
       return (n >= i->Low) && (n <= i->High);
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/Indexing.def", 25, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/gm2-libs/Indexing.def", 25, 1);
   __builtin_unreachable ();
 }
 
@@ -247,7 +247,7 @@ extern "C" unsigned int Indexing_HighIndice (Indexing_Index i)
     {
       return i->High;
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/Indexing.def", 25, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/gm2-libs/Indexing.def", 25, 1);
   __builtin_unreachable ();
 }
 
@@ -267,7 +267,7 @@ extern "C" unsigned int Indexing_LowIndice (Indexing_Index i)
     {
       return i->Low;
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/Indexing.def", 25, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/gm2-libs/Indexing.def", 25, 1);
   __builtin_unreachable ();
 }
 
diff --git a/gcc/m2/pge-boot/GM2Dependent.c b/gcc/m2/pge-boot/GM2Dependent.c
index 368cf33..32c777c 100644
--- a/gcc/m2/pge-boot/GM2Dependent.c
+++ b/gcc/m2/pge-boot/GM2Dependent.c
@@ -458,7 +458,7 @@ static void toCString (char *str, unsigned int _str_high)
   high = _str_high;
   while (i < high)
     {
-      if ((str[i] == '\\') && (i < high))
+      if ((i < high) && (str[i] == '\\'))
         {
           if (str[i+1] == 'n')
             {
diff --git a/gcc/m2/pge-boot/GM2EXCEPTION.c b/gcc/m2/pge-boot/GM2EXCEPTION.c
index ce54442..5a3ba4c 100644
--- a/gcc/m2/pge-boot/GM2EXCEPTION.c
+++ b/gcc/m2/pge-boot/GM2EXCEPTION.c
@@ -56,13 +56,13 @@ extern "C" M2EXCEPTION_M2Exceptions M2EXCEPTION_M2Exception (void)
   n = RTExceptions_GetNumber (e);
   if (n == (UINT_MAX))
     {
-      RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_exException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/M2EXCEPTION.mod")), 47, 6, const_cast<void*> (reinterpret_cast<const void*>("M2Exception")), const_cast<void*> (reinterpret_cast<const void*>("current coroutine is not in the exceptional execution state")));
+      RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_exException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-read-write/gcc/m2/gm2-libs/M2EXCEPTION.mod")), 47, 6, const_cast<void*> (reinterpret_cast<const void*>("M2Exception")), const_cast<void*> (reinterpret_cast<const void*>("current coroutine is not in the exceptional execution state")));
     }
   else
     {
       return (M2EXCEPTION_M2Exceptions) (n);
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/M2EXCEPTION.def", 25, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/gm2-libs/M2EXCEPTION.def", 25, 1);
   __builtin_unreachable ();
 }
 
diff --git a/gcc/m2/pge-boot/GM2RTS.c b/gcc/m2/pge-boot/GM2RTS.c
index 99f75ad..1fdd5eb 100644
--- a/gcc/m2/pge-boot/GM2RTS.c
+++ b/gcc/m2/pge-boot/GM2RTS.c
@@ -64,6 +64,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 
 typedef struct M2RTS_ArgCVEnvP_p M2RTS_ArgCVEnvP;
 
+#   define stderrFd 2
 typedef struct M2RTS_ProcedureList_r M2RTS_ProcedureList;
 
 typedef char *M2RTS_PtrToChar;
@@ -178,10 +179,19 @@ extern "C" void M2RTS_HALT (int exitcode) __attribute__ ((noreturn));
 
 /*
    Halt - provides a more user friendly version of HALT, which takes
-          four parameters to aid debugging.
+          four parameters to aid debugging.  It writes an error message
+          to stderr and calls exit (1).
 */
 
-extern "C" void M2RTS_Halt (const char *file_, unsigned int _file_high, unsigned int line, const char *function_, unsigned int _function_high, const char *description_, unsigned int _description_high) __attribute__ ((noreturn));
+extern "C" void M2RTS_Halt (const char *filename_, unsigned int _filename_high, unsigned int line, const char *function_, unsigned int _function_high, const char *description_, unsigned int _description_high) __attribute__ ((noreturn));
+
+/*
+   HaltC - provides a more user friendly version of HALT, which takes
+           four parameters to aid debugging.  It writes an error message
+           to stderr and calls exit (1).
+*/
+
+extern "C" void M2RTS_HaltC (void * filename, unsigned int line, void * function, void * description);
 
 /*
    ExitOnHalt - if HALT is executed then call exit with the exit code, e.
@@ -193,7 +203,7 @@ extern "C" void M2RTS_ExitOnHalt (int e);
    ErrorMessage - emits an error message to stderr and then calls exit (1).
 */
 
-extern "C" void M2RTS_ErrorMessage (const char *message_, unsigned int _message_high, const char *file_, unsigned int _file_high, unsigned int line, const char *function_, unsigned int _function_high) __attribute__ ((noreturn));
+extern "C" void M2RTS_ErrorMessage (const char *message_, unsigned int _message_high, const char *filename_, unsigned int _filename_high, unsigned int line, const char *function_, unsigned int _function_high) __attribute__ ((noreturn));
 
 /*
    Length - returns the length of a string, a. This is called whenever
@@ -249,6 +259,18 @@ static unsigned int AppendProc (M2RTS_ProcedureList *proclist, PROC proc);
 static void ErrorString (const char *a_, unsigned int _a_high);
 
 /*
+   ErrorStringC - writes a string to stderr.
+*/
+
+static void ErrorStringC (void * str);
+
+/*
+   ErrorMessageC - emits an error message to stderr and then calls exit (1).
+*/
+
+static void ErrorMessageC (void * message, void * filename, unsigned int line, void * function) __attribute__ ((noreturn));
+
+/*
    InitProcList - initialize the head and tail pointers to NIL.
 */
 
@@ -322,7 +344,49 @@ static void ErrorString (const char *a_, unsigned int _a_high)
   /* make a local copy of each unbounded array.  */
   memcpy (a, a_, _a_high+1);
 
-  n = static_cast<int> (libc_write (2, &a, static_cast<size_t> (StrLib_StrLen ((const char *) a, _a_high))));
+  n = static_cast<int> (libc_write (stderrFd, &a, static_cast<size_t> (StrLib_StrLen ((const char *) a, _a_high))));
+}
+
+
+/*
+   ErrorStringC - writes a string to stderr.
+*/
+
+static void ErrorStringC (void * str)
+{
+  int len;
+
+  len = static_cast<int> (libc_write (stderrFd, str, libc_strlen (str)));
+}
+
+
+/*
+   ErrorMessageC - emits an error message to stderr and then calls exit (1).
+*/
+
+static void ErrorMessageC (void * message, void * filename, unsigned int line, void * function)
+{
+  typedef struct ErrorMessageC__T2_a ErrorMessageC__T2;
+
+  struct ErrorMessageC__T2_a { char array[10+1]; };
+  ErrorMessageC__T2 buffer;
+
+  ErrorStringC (filename);
+  ErrorString ((const char *) ":", 1);
+  NumberIO_CardToStr (line, 0, (char *) &buffer.array[0], 10);
+  ErrorString ((const char *) &buffer.array[0], 10);
+  ErrorString ((const char *) ":", 1);
+  if ((libc_strlen (function)) > 0)
+    {
+      ErrorString ((const char *) "in ", 3);
+      ErrorStringC (function);
+      ErrorString ((const char *) " has caused ", 12);
+    }
+  ErrorStringC (message);
+  buffer.array[0] = ASCII_nl;
+  buffer.array[1] = ASCII_nul;
+  ErrorString ((const char *) &buffer.array[0], 10);
+  libc_exit (1);
 }
 
 
@@ -519,23 +583,34 @@ extern "C" void M2RTS_HALT (int exitcode)
 
 /*
    Halt - provides a more user friendly version of HALT, which takes
-          four parameters to aid debugging.
+          four parameters to aid debugging.  It writes an error message
+          to stderr and calls exit (1).
 */
 
-extern "C" void M2RTS_Halt (const char *file_, unsigned int _file_high, unsigned int line, const char *function_, unsigned int _function_high, const char *description_, unsigned int _description_high)
+extern "C" void M2RTS_Halt (const char *filename_, unsigned int _filename_high, unsigned int line, const char *function_, unsigned int _function_high, const char *description_, unsigned int _description_high)
 {
-  char file[_file_high+1];
+  char filename[_filename_high+1];
   char function[_function_high+1];
   char description[_description_high+1];
 
   /* make a local copy of each unbounded array.  */
-  memcpy (file, file_, _file_high+1);
+  memcpy (filename, filename_, _filename_high+1);
   memcpy (function, function_, _function_high+1);
   memcpy (description, description_, _description_high+1);
 
-  M2RTS_ErrorMessage ((const char *) description, _description_high, (const char *) file, _file_high, line, (const char *) function, _function_high);
-  M2RTS_HALT (-1);
-  __builtin_unreachable ();
+  M2RTS_ErrorMessage ((const char *) description, _description_high, (const char *) filename, _filename_high, line, (const char *) function, _function_high);
+}
+
+
+/*
+   HaltC - provides a more user friendly version of HALT, which takes
+           four parameters to aid debugging.  It writes an error message
+           to stderr and calls exit (1).
+*/
+
+extern "C" void M2RTS_HaltC (void * filename, unsigned int line, void * function, void * description)
+{
+  ErrorMessageC (description, filename, line, function);
 }
 
 
@@ -554,25 +629,25 @@ extern "C" void M2RTS_ExitOnHalt (int e)
    ErrorMessage - emits an error message to stderr and then calls exit (1).
 */
 
-extern "C" void M2RTS_ErrorMessage (const char *message_, unsigned int _message_high, const char *file_, unsigned int _file_high, unsigned int line, const char *function_, unsigned int _function_high)
+extern "C" void M2RTS_ErrorMessage (const char *message_, unsigned int _message_high, const char *filename_, unsigned int _filename_high, unsigned int line, const char *function_, unsigned int _function_high)
 {
-  typedef struct ErrorMessage__T2_a ErrorMessage__T2;
+  typedef struct ErrorMessage__T3_a ErrorMessage__T3;
 
-  struct ErrorMessage__T2_a { char array[10+1]; };
-  ErrorMessage__T2 LineNo;
+  struct ErrorMessage__T3_a { char array[10+1]; };
+  ErrorMessage__T3 buffer;
   char message[_message_high+1];
-  char file[_file_high+1];
+  char filename[_filename_high+1];
   char function[_function_high+1];
 
   /* make a local copy of each unbounded array.  */
   memcpy (message, message_, _message_high+1);
-  memcpy (file, file_, _file_high+1);
+  memcpy (filename, filename_, _filename_high+1);
   memcpy (function, function_, _function_high+1);
 
-  ErrorString ((const char *) file, _file_high);
+  ErrorString ((const char *) filename, _filename_high);
   ErrorString ((const char *) ":", 1);
-  NumberIO_CardToStr (line, 0, (char *) &LineNo.array[0], 10);
-  ErrorString ((const char *) &LineNo.array[0], 10);
+  NumberIO_CardToStr (line, 0, (char *) &buffer.array[0], 10);
+  ErrorString ((const char *) &buffer.array[0], 10);
   ErrorString ((const char *) ":", 1);
   if (! (StrLib_StrEqual ((const char *) function, _function_high, (const char *) "", 0)))
     {
@@ -581,9 +656,9 @@ extern "C" void M2RTS_ErrorMessage (const char *message_, unsigned int _message_
       ErrorString ((const char *) " has caused ", 12);
     }
   ErrorString ((const char *) message, _message_high);
-  LineNo.array[0] = ASCII_nl;
-  LineNo.array[1] = ASCII_nul;
-  ErrorString ((const char *) &LineNo.array[0], 10);
+  buffer.array[0] = ASCII_nl;
+  buffer.array[1] = ASCII_nul;
+  ErrorString ((const char *) &buffer.array[0], 10);
   libc_exit (1);
 }
 
diff --git a/gcc/m2/pge-boot/GNameKey.c b/gcc/m2/pge-boot/GNameKey.c
index ad5b3b7..13511cb 100644
--- a/gcc/m2/pge-boot/GNameKey.c
+++ b/gcc/m2/pge-boot/GNameKey.c
@@ -330,7 +330,7 @@ extern "C" NameKey_Name NameKey_MakeKey (const char *a_, unsigned int _a_high)
       (*p) = ASCII_nul;
       return DoMakeKey (n, higha);
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/gm2-compiler/NameKey.def", 20, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/gm2-compiler/NameKey.def", 20, 1);
   __builtin_unreachable ();
 }
 
@@ -380,7 +380,7 @@ extern "C" NameKey_Name NameKey_makekey (void * a)
           return DoMakeKey (n, higha);
         }
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/gm2-compiler/NameKey.def", 20, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/gm2-compiler/NameKey.def", 20, 1);
   __builtin_unreachable ();
 }
 
diff --git a/gcc/m2/pge-boot/GPushBackInput.c b/gcc/m2/pge-boot/GPushBackInput.c
index 57a39d5..70cb272 100644
--- a/gcc/m2/pge-boot/GPushBackInput.c
+++ b/gcc/m2/pge-boot/GPushBackInput.c
@@ -275,7 +275,7 @@ extern "C" char PushBackInput_PutCh (char ch)
     }
   else
     {
-      Debug_Halt ((const char *) "max push back stack exceeded, increase MaxPushBackStack", 55, 150, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/PushBackInput.mod", 61);
+      Debug_Halt ((const char *) "max push back stack exceeded, increase MaxPushBackStack", 55, 150, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/PushBackInput.mod", 54);
     }
   return ch;
   /* static analysis guarentees a RETURN statement will be used before here.  */
@@ -301,7 +301,7 @@ extern "C" void PushBackInput_PutString (const char *a_, unsigned int _a_high)
       l -= 1;
       if ((PushBackInput_PutCh (a[l])) != a[l])
         {
-          Debug_Halt ((const char *) "assert failed", 13, 132, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/PushBackInput.mod", 61);
+          Debug_Halt ((const char *) "assert failed", 13, 132, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/PushBackInput.mod", 54);
         }
     }
 }
@@ -322,7 +322,7 @@ extern "C" void PushBackInput_PutStr (DynamicStrings_String s)
       i -= 1;
       if ((PushBackInput_PutCh (DynamicStrings_char (s, static_cast<int> (i)))) != (DynamicStrings_char (s, static_cast<int> (i))))
         {
-          Debug_Halt ((const char *) "assert failed", 13, 113, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/PushBackInput.mod", 61);
+          Debug_Halt ((const char *) "assert failed", 13, 113, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/PushBackInput.mod", 54);
         }
     }
 }
diff --git a/gcc/m2/pge-boot/GRTExceptions.c b/gcc/m2/pge-boot/GRTExceptions.c
index d43ab45..84f6cca 100644
--- a/gcc/m2/pge-boot/GRTExceptions.c
+++ b/gcc/m2/pge-boot/GRTExceptions.c
@@ -722,7 +722,7 @@ static void AddHandler (RTExceptions_EHBlock e, RTExceptions_Handler h)
 
 static void indexf (void * a)
 {
-  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_indexException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTExceptions.mod")), 612, 9, const_cast<void*> (reinterpret_cast<const void*>("indexf")), const_cast<void*> (reinterpret_cast<const void*>("array index out of bounds")));
+  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_indexException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-read-write/gcc/m2/gm2-libs/RTExceptions.mod")), 612, 9, const_cast<void*> (reinterpret_cast<const void*>("indexf")), const_cast<void*> (reinterpret_cast<const void*>("array index out of bounds")));
 }
 
 
@@ -732,7 +732,7 @@ static void indexf (void * a)
 
 static void range (void * a)
 {
-  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_rangeException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTExceptions.mod")), 624, 9, const_cast<void*> (reinterpret_cast<const void*>("range")), const_cast<void*> (reinterpret_cast<const void*>("assignment out of range")));
+  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_rangeException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-read-write/gcc/m2/gm2-libs/RTExceptions.mod")), 624, 9, const_cast<void*> (reinterpret_cast<const void*>("range")), const_cast<void*> (reinterpret_cast<const void*>("assignment out of range")));
 }
 
 
@@ -742,7 +742,7 @@ static void range (void * a)
 
 static void casef (void * a)
 {
-  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_caseSelectException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTExceptions.mod")), 636, 9, const_cast<void*> (reinterpret_cast<const void*>("casef")), const_cast<void*> (reinterpret_cast<const void*>("case selector out of range")));
+  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_caseSelectException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-read-write/gcc/m2/gm2-libs/RTExceptions.mod")), 636, 9, const_cast<void*> (reinterpret_cast<const void*>("casef")), const_cast<void*> (reinterpret_cast<const void*>("case selector out of range")));
 }
 
 
@@ -752,7 +752,7 @@ static void casef (void * a)
 
 static void invalidloc (void * a)
 {
-  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_invalidLocation)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTExceptions.mod")), 648, 9, const_cast<void*> (reinterpret_cast<const void*>("invalidloc")), const_cast<void*> (reinterpret_cast<const void*>("invalid address referenced")));
+  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_invalidLocation)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-read-write/gcc/m2/gm2-libs/RTExceptions.mod")), 648, 9, const_cast<void*> (reinterpret_cast<const void*>("invalidloc")), const_cast<void*> (reinterpret_cast<const void*>("invalid address referenced")));
 }
 
 
@@ -762,7 +762,7 @@ static void invalidloc (void * a)
 
 static void function (void * a)
 {
-  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_functionException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTExceptions.mod")), 660, 9, const_cast<void*> (reinterpret_cast<const void*>("function")), const_cast<void*> (reinterpret_cast<const void*>("... function ... ")));  /* --fixme-- what has happened ?  */
+  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_functionException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-read-write/gcc/m2/gm2-libs/RTExceptions.mod")), 660, 9, const_cast<void*> (reinterpret_cast<const void*>("function")), const_cast<void*> (reinterpret_cast<const void*>("... function ... ")));  /* --fixme-- what has happened ?  */
 }
 
 
@@ -772,7 +772,7 @@ static void function (void * a)
 
 static void wholevalue (void * a)
 {
-  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_wholeValueException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTExceptions.mod")), 672, 9, const_cast<void*> (reinterpret_cast<const void*>("wholevalue")), const_cast<void*> (reinterpret_cast<const void*>("illegal whole value exception")));
+  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_wholeValueException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-read-write/gcc/m2/gm2-libs/RTExceptions.mod")), 672, 9, const_cast<void*> (reinterpret_cast<const void*>("wholevalue")), const_cast<void*> (reinterpret_cast<const void*>("illegal whole value exception")));
 }
 
 
@@ -782,7 +782,7 @@ static void wholevalue (void * a)
 
 static void wholediv (void * a)
 {
-  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_wholeDivException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTExceptions.mod")), 684, 9, const_cast<void*> (reinterpret_cast<const void*>("wholediv")), const_cast<void*> (reinterpret_cast<const void*>("illegal whole value exception")));
+  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_wholeDivException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-read-write/gcc/m2/gm2-libs/RTExceptions.mod")), 684, 9, const_cast<void*> (reinterpret_cast<const void*>("wholediv")), const_cast<void*> (reinterpret_cast<const void*>("illegal whole value exception")));
 }
 
 
@@ -792,7 +792,7 @@ static void wholediv (void * a)
 
 static void realvalue (void * a)
 {
-  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_realValueException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTExceptions.mod")), 696, 9, const_cast<void*> (reinterpret_cast<const void*>("realvalue")), const_cast<void*> (reinterpret_cast<const void*>("illegal real value exception")));
+  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_realValueException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-read-write/gcc/m2/gm2-libs/RTExceptions.mod")), 696, 9, const_cast<void*> (reinterpret_cast<const void*>("realvalue")), const_cast<void*> (reinterpret_cast<const void*>("illegal real value exception")));
 }
 
 
@@ -802,7 +802,7 @@ static void realvalue (void * a)
 
 static void realdiv (void * a)
 {
-  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_realDivException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTExceptions.mod")), 708, 9, const_cast<void*> (reinterpret_cast<const void*>("realdiv")), const_cast<void*> (reinterpret_cast<const void*>("real number division by zero exception")));
+  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_realDivException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-read-write/gcc/m2/gm2-libs/RTExceptions.mod")), 708, 9, const_cast<void*> (reinterpret_cast<const void*>("realdiv")), const_cast<void*> (reinterpret_cast<const void*>("real number division by zero exception")));
 }
 
 
@@ -812,7 +812,7 @@ static void realdiv (void * a)
 
 static void complexvalue (void * a)
 {
-  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_complexValueException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTExceptions.mod")), 720, 9, const_cast<void*> (reinterpret_cast<const void*>("complexvalue")), const_cast<void*> (reinterpret_cast<const void*>("illegal complex value exception")));
+  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_complexValueException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-read-write/gcc/m2/gm2-libs/RTExceptions.mod")), 720, 9, const_cast<void*> (reinterpret_cast<const void*>("complexvalue")), const_cast<void*> (reinterpret_cast<const void*>("illegal complex value exception")));
 }
 
 
@@ -822,7 +822,7 @@ static void complexvalue (void * a)
 
 static void complexdiv (void * a)
 {
-  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_complexDivException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTExceptions.mod")), 732, 9, const_cast<void*> (reinterpret_cast<const void*>("complexdiv")), const_cast<void*> (reinterpret_cast<const void*>("complex number division by zero exception")));
+  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_complexDivException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-read-write/gcc/m2/gm2-libs/RTExceptions.mod")), 732, 9, const_cast<void*> (reinterpret_cast<const void*>("complexdiv")), const_cast<void*> (reinterpret_cast<const void*>("complex number division by zero exception")));
 }
 
 
@@ -832,7 +832,7 @@ static void complexdiv (void * a)
 
 static void protection (void * a)
 {
-  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_protException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTExceptions.mod")), 744, 9, const_cast<void*> (reinterpret_cast<const void*>("protection")), const_cast<void*> (reinterpret_cast<const void*>("protection exception")));
+  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_protException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-read-write/gcc/m2/gm2-libs/RTExceptions.mod")), 744, 9, const_cast<void*> (reinterpret_cast<const void*>("protection")), const_cast<void*> (reinterpret_cast<const void*>("protection exception")));
 }
 
 
@@ -842,7 +842,7 @@ static void protection (void * a)
 
 static void systemf (void * a)
 {
-  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_sysException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTExceptions.mod")), 756, 9, const_cast<void*> (reinterpret_cast<const void*>("systemf")), const_cast<void*> (reinterpret_cast<const void*>("system exception")));
+  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_sysException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-read-write/gcc/m2/gm2-libs/RTExceptions.mod")), 756, 9, const_cast<void*> (reinterpret_cast<const void*>("systemf")), const_cast<void*> (reinterpret_cast<const void*>("system exception")));
 }
 
 
@@ -852,7 +852,7 @@ static void systemf (void * a)
 
 static void coroutine (void * a)
 {
-  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_coException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTExceptions.mod")), 768, 9, const_cast<void*> (reinterpret_cast<const void*>("coroutine")), const_cast<void*> (reinterpret_cast<const void*>("coroutine exception")));
+  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_coException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-read-write/gcc/m2/gm2-libs/RTExceptions.mod")), 768, 9, const_cast<void*> (reinterpret_cast<const void*>("coroutine")), const_cast<void*> (reinterpret_cast<const void*>("coroutine exception")));
 }
 
 
@@ -862,7 +862,7 @@ static void coroutine (void * a)
 
 static void exception (void * a)
 {
-  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_exException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTExceptions.mod")), 780, 9, const_cast<void*> (reinterpret_cast<const void*>("exception")), const_cast<void*> (reinterpret_cast<const void*>("exception exception")));
+  RTExceptions_Raise ( ((unsigned int) (M2EXCEPTION_exException)), const_cast<void*> (reinterpret_cast<const void*>("../../gcc-read-write/gcc/m2/gm2-libs/RTExceptions.mod")), 780, 9, const_cast<void*> (reinterpret_cast<const void*>("exception")), const_cast<void*> (reinterpret_cast<const void*>("exception exception")));
 }
 
 
@@ -1181,13 +1181,13 @@ extern "C" RTExceptions_EHBlock RTExceptions_GetBaseExceptionBlock (void)
 {
   if (currentEHB == NULL)
     {
-      M2RTS_Halt ((const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTExceptions.mod", 60, 598, (const char *) "GetBaseExceptionBlock", 21, (const char *) "currentEHB has not been initialized yet", 39);
+      M2RTS_Halt ((const char *) "../../gcc-read-write/gcc/m2/gm2-libs/RTExceptions.mod", 53, 598, (const char *) "GetBaseExceptionBlock", 21, (const char *) "currentEHB has not been initialized yet", 39);
     }
   else
     {
       return currentEHB;
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/RTExceptions.def", 25, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/gm2-libs/RTExceptions.def", 25, 1);
   __builtin_unreachable ();
 }
 
diff --git a/gcc/m2/pge-boot/GStdIO.c b/gcc/m2/pge-boot/GStdIO.c
index 2343bf3..04af632 100644
--- a/gcc/m2/pge-boot/GStdIO.c
+++ b/gcc/m2/pge-boot/GStdIO.c
@@ -191,7 +191,7 @@ extern "C" StdIO_ProcWrite StdIO_GetCurrentOutput (void)
       M2RTS_HALT (-1);
       __builtin_unreachable ();
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/StdIO.def", 25, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/gm2-libs/StdIO.def", 25, 1);
   __builtin_unreachable ();
 }
 
@@ -250,7 +250,7 @@ extern "C" StdIO_ProcRead StdIO_GetCurrentInput (void)
       M2RTS_HALT (-1);
       __builtin_unreachable ();
     }
-  ReturnException ("../../gcc-git-devel-modula2/gcc/m2/gm2-libs/StdIO.def", 25, 1);
+  ReturnException ("../../gcc-read-write/gcc/m2/gm2-libs/StdIO.def", 25, 1);
   __builtin_unreachable ();
 }
 
diff --git a/gcc/m2/pge-boot/GSymbolKey.c b/gcc/m2/pge-boot/GSymbolKey.c
index 9121d87..61c599e 100644
--- a/gcc/m2/pge-boot/GSymbolKey.c
+++ b/gcc/m2/pge-boot/GSymbolKey.c
@@ -183,7 +183,7 @@ static void FindNodeParentInTree (SymbolKey_SymbolTree t, NameKey_Name n, Symbol
   (*parent) = t;
   if (t == NULL)
     {
-      Debug_Halt ((const char *) "parameter t should never be NIL", 31, 240, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-compiler/SymbolKey.mod", 61);
+      Debug_Halt ((const char *) "parameter t should never be NIL", 31, 240, (const char *) "../../gcc-read-write/gcc/m2/gm2-compiler/SymbolKey.mod", 54);
     }
   Assertion_Assert (t->Right == NULL);
   (*child) = t->Left;
@@ -392,7 +392,7 @@ extern "C" void SymbolKey_PutSymKey (SymbolKey_SymbolTree t, NameKey_Name NameKe
     }
   else
     {
-      Debug_Halt ((const char *) "symbol already stored", 21, 156, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-compiler/SymbolKey.mod", 61);
+      Debug_Halt ((const char *) "symbol already stored", 21, 156, (const char *) "../../gcc-read-write/gcc/m2/gm2-compiler/SymbolKey.mod", 54);
     }
 }
 
@@ -459,7 +459,7 @@ extern "C" void SymbolKey_DelSymKey (SymbolKey_SymbolTree t, NameKey_Name NameKe
     }
   else
     {
-      Debug_Halt ((const char *) "trying to delete a symbol that is not in the tree - the compiler never expects this to occur", 92, 223, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-compiler/SymbolKey.mod", 61);
+      Debug_Halt ((const char *) "trying to delete a symbol that is not in the tree - the compiler never expects this to occur", 92, 223, (const char *) "../../gcc-read-write/gcc/m2/gm2-compiler/SymbolKey.mod", 54);
     }
 }
 
diff --git a/gcc/m2/pge-boot/GSysStorage.c b/gcc/m2/pge-boot/GSysStorage.c
index 40a464e..f2a7038 100644
--- a/gcc/m2/pge-boot/GSysStorage.c
+++ b/gcc/m2/pge-boot/GSysStorage.c
@@ -93,7 +93,7 @@ extern "C" void SysStorage_ALLOCATE (void * *a, unsigned int size)
   (*a) = libc_malloc (static_cast<size_t> (size));
   if ((*a) == NULL)
     {
-      Debug_Halt ((const char *) "out of memory error", 19, 50, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/SysStorage.mod", 58);
+      Debug_Halt ((const char *) "out of memory error", 19, 50, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/SysStorage.mod", 51);
     }
   if (enableTrace && trace)
     {
@@ -118,7 +118,7 @@ extern "C" void SysStorage_DEALLOCATE (void * *a, unsigned int size)
         }
       if ((libc_memset ((*a), 0, static_cast<size_t> (size))) != (*a))
         {
-          Debug_Halt ((const char *) "memset should have returned the first parameter", 47, 76, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/SysStorage.mod", 58);
+          Debug_Halt ((const char *) "memset should have returned the first parameter", 47, 76, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/SysStorage.mod", 51);
         }
     }
   if (enableDeallocation)
@@ -163,7 +163,7 @@ extern "C" void SysStorage_REALLOCATE (void * *a, unsigned int size)
       (*a) = libc_realloc ((*a), static_cast<size_t> (size));
       if ((*a) == NULL)
         {
-          Debug_Halt ((const char *) "out of memory error", 19, 119, (const char *) "../../gcc-git-devel-modula2/gcc/m2/gm2-libs/SysStorage.mod", 58);
+          Debug_Halt ((const char *) "out of memory error", 19, 119, (const char *) "../../gcc-read-write/gcc/m2/gm2-libs/SysStorage.mod", 51);
         }
       if (enableTrace && trace)
         {
diff --git a/gcc/m2/tools-src/makeSystem b/gcc/m2/tools-src/makeSystem
index 49b58a2..b1156b5 100644
--- a/gcc/m2/tools-src/makeSystem
+++ b/gcc/m2/tools-src/makeSystem
@@ -23,7 +23,7 @@
 
 
 Usage () {
-   echo "Usage: makesystem dialectflag SYSTEM.def SYSTEM.mod librarypath compiler"
+   echo "Usage: makesystem dialectflag SYSTEM.def SYSTEM.mod { librarypath } compiler"
 }
 
 if [ $# -lt 6 ] ; then
@@ -34,9 +34,18 @@ fi
 DIALECT=$1
 SYSTEMDEF=$2
 SYSTEMMOD=$3
-LIBRARY=$4
-COMPILER=$5
-OUTPUTFILE=$6
+shift 3
+LIBRARY=""
+while [ $# -gt 2 ] ; do
+    if [ "$LIBRARY" = "" ] ; then
+	LIBRARY=$1
+    else
+	LIBRARY="${LIBRARY} $1"
+    fi
+    shift
+done
+COMPILER=$1
+OUTPUTFILE=$2
 
 if [ "$COMPILER" = "" ] ; then
     echo "parameter 5 of makeSystem is incorrect, GM2_FOR_TARGET was unset"
diff --git a/gcc/match.pd b/gcc/match.pd
index 56ac743..f605b79 100644
--- a/gcc/match.pd
+++ b/gcc/match.pd
@@ -339,6 +339,20 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
  (if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (@0)))
   (COPYSIGN_ALL (negate @0) @1)))
 
+/* Transform c ? x * copysign (1, y) : z to c ? x ^ signs(y) : z.
+   tree-ssa-math-opts.cc does the corresponding optimization for
+   unconditional multiplications (via xorsign).  */
+(simplify
+ (IFN_COND_MUL:c @0 @1 (IFN_COPYSIGN real_onep @2) @3)
+ (with { tree signs = sign_mask_for (type); }
+  (if (signs)
+   (with { tree inttype = TREE_TYPE (signs); }
+    (view_convert:type
+     (IFN_COND_XOR:inttype @0
+      (view_convert:inttype @1)
+      (bit_and (view_convert:inttype @2) { signs; })
+      (view_convert:inttype @3)))))))
+
 /* (x >= 0 ? x : 0) + (x <= 0 ? -x : 0) -> abs x.  */
 (simplify
   (plus:c (max @0 integer_zerop) (max (negate @0) integer_zerop))
diff --git a/gcc/omp-expand.cc b/gcc/omp-expand.cc
index c7ef419..940454b 100644
--- a/gcc/omp-expand.cc
+++ b/gcc/omp-expand.cc
@@ -2003,8 +2003,8 @@ expand_omp_for_init_counts (struct omp_for_data *fd, gimple_stmt_iterator *gsi,
 	    t = fold_build2 (MINUS_EXPR, itype, unshare_expr (fd->loops[i].m2),
 			     unshare_expr (fd->loops[i].m1));
 	  else if (fd->loops[i].m1)
-	    t = fold_unary (NEGATE_EXPR, itype,
-			    unshare_expr (fd->loops[i].m1));
+	    t = fold_build1 (NEGATE_EXPR, itype,
+			     unshare_expr (fd->loops[i].m1));
 	  else
 	    t = unshare_expr (fd->loops[i].m2);
 	  tree m2minusm1
diff --git a/gcc/optc-save-gen.awk b/gcc/optc-save-gen.awk
index e91adf7..d2cb53c 100644
--- a/gcc/optc-save-gen.awk
+++ b/gcc/optc-save-gen.awk
@@ -1013,7 +1013,7 @@ for (i = 0; i < n_target_string; i++) {
 	print "             indent, \"\",";
 	print "             \"" name "\",";
 	print "             ptr1->x_" name " ? ptr1->x_" name " : \"(null)\",";
-	print "             ptr2->x_" name " ? ptr1->x_" name " : \"(null)\");";
+	print "             ptr2->x_" name " ? ptr2->x_" name " : \"(null)\");";
 	print "";
 }
 
diff --git a/gcc/opts.cc b/gcc/opts.cc
index 9ba47d7..a032cd4 100644
--- a/gcc/opts.cc
+++ b/gcc/opts.cc
@@ -2246,7 +2246,14 @@ parse_sanitizer_options (const char *p, location_t loc, int scode,
 		  flags |= sanitizer_opts[i].flag;
 	      }
 	    else
-	      flags &= ~sanitizer_opts[i].flag;
+	      {
+		flags &= ~sanitizer_opts[i].flag;
+		/* Don't always clear SANITIZE_ADDRESS if it was previously
+		   set: -fsanitize=address -fno-sanitize=kernel-address should
+		   leave SANITIZE_ADDRESS set.  */
+		if (flags & (SANITIZE_KERNEL_ADDRESS | SANITIZE_USER_ADDRESS))
+		  flags |= SANITIZE_ADDRESS;
+	      }
 	    found = true;
 	    break;
 	  }
diff --git a/gcc/range-op-float.cc b/gcc/range-op-float.cc
index 74ac465..2db83ae 100644
--- a/gcc/range-op-float.cc
+++ b/gcc/range-op-float.cc
@@ -607,6 +607,10 @@ foperator_equal::fold_range (irange &r, tree type,
     {
       if (op1 == op2)
 	r = range_true (type);
+      // If one operand is -0.0 and other 0.0, they are still equal.
+      else if (real_iszero (&op1.lower_bound ())
+	       && real_iszero (&op2.lower_bound ()))
+	r = range_true (type);
       else
 	r = range_false (type);
     }
@@ -617,7 +621,18 @@ foperator_equal::fold_range (irange &r, tree type,
       frange tmp = op1;
       tmp.intersect (op2);
       if (tmp.undefined_p ())
-	r = range_false (type);
+	{
+	  // If one range is [whatever, -0.0] and another
+	  // [0.0, whatever2], we don't know anything either,
+	  // because -0.0 == 0.0.
+	  if ((real_iszero (&op1.upper_bound ())
+	       && real_iszero (&op2.lower_bound ()))
+	      || (real_iszero (&op1.lower_bound ())
+		  && real_iszero (&op2.upper_bound ())))
+	    r = range_true_and_false (type);
+	  else
+	    r = range_false (type);
+	}
       else
 	r = range_true_and_false (type);
     }
@@ -708,10 +723,14 @@ foperator_not_equal::fold_range (irange &r, tree type,
   // consist of a single value, and then compare them.
   else if (op1.singleton_p () && op2.singleton_p ())
     {
-      if (op1 != op2)
-	r = range_true (type);
-      else
+      if (op1 == op2)
 	r = range_false (type);
+      // If one operand is -0.0 and other 0.0, they are still equal.
+      else if (real_iszero (&op1.lower_bound ())
+	       && real_iszero (&op2.lower_bound ()))
+	r = range_false (type);
+      else
+	r = range_true (type);
     }
   else if (!maybe_isnan (op1, op2))
     {
@@ -720,7 +739,18 @@ foperator_not_equal::fold_range (irange &r, tree type,
       frange tmp = op1;
       tmp.intersect (op2);
       if (tmp.undefined_p ())
-	r = range_true (type);
+	{
+	  // If one range is [whatever, -0.0] and another
+	  // [0.0, whatever2], we don't know anything either,
+	  // because -0.0 == 0.0.
+	  if ((real_iszero (&op1.upper_bound ())
+	       && real_iszero (&op2.lower_bound ()))
+	      || (real_iszero (&op1.lower_bound ())
+		  && real_iszero (&op2.upper_bound ())))
+	    r = range_true_and_false (type);
+	  else
+	    r = range_true (type);
+	}
       else
 	r = range_true_and_false (type);
     }
diff --git a/gcc/range-op.cc b/gcc/range-op.cc
index ec75e07..6e5754e 100644
--- a/gcc/range-op.cc
+++ b/gcc/range-op.cc
@@ -2166,7 +2166,7 @@ operator_lshift::fold_range (irange &r, tree type,
       if (op2.undefined_p ())
 	r.set_undefined ();
       else
-	r.set_varying (type);
+	r.set_zero (type);
       return true;
     }
 
@@ -2440,7 +2440,7 @@ operator_rshift::fold_range (irange &r, tree type,
       if (op2.undefined_p ())
 	r.set_undefined ();
       else
-	r.set_varying (type);
+	r.set_zero (type);
       return true;
     }
 
diff --git a/gcc/sched-deps.cc b/gcc/sched-deps.cc
index f9371b8..a9214f6 100644
--- a/gcc/sched-deps.cc
+++ b/gcc/sched-deps.cc
@@ -2605,26 +2605,26 @@ sched_analyze_2 (class deps_desc *deps, rtx x, rtx_insn *insn)
 
     case MEM:
       {
-	/* Reading memory.  */
-	rtx_insn_list *u;
-	rtx_insn_list *pending;
-	rtx_expr_list *pending_mem;
-	rtx t = x;
-
-	if (sched_deps_info->use_cselib)
-	  {
-	    machine_mode address_mode = get_address_mode (t);
-
-	    t = shallow_copy_rtx (t);
-	    cselib_lookup_from_insn (XEXP (t, 0), address_mode, 1,
-				     GET_MODE (t), insn);
-	    XEXP (t, 0)
-	      = cselib_subst_to_values_from_insn (XEXP (t, 0), GET_MODE (t),
-						  insn);
-	  }
-
 	if (!DEBUG_INSN_P (insn))
 	  {
+	    /* Reading memory.  */
+	    rtx_insn_list *u;
+	    rtx_insn_list *pending;
+	    rtx_expr_list *pending_mem;
+	    rtx t = x;
+
+	    if (sched_deps_info->use_cselib)
+	      {
+		machine_mode address_mode = get_address_mode (t);
+
+		t = shallow_copy_rtx (t);
+		cselib_lookup_from_insn (XEXP (t, 0), address_mode, 1,
+					 GET_MODE (t), insn);
+		XEXP (t, 0)
+		  = cselib_subst_to_values_from_insn (XEXP (t, 0), GET_MODE (t),
+						      insn);
+	      }
+
 	    t = canon_rtx (t);
 	    pending = deps->pending_read_insns;
 	    pending_mem = deps->pending_read_mems;
diff --git a/gcc/selftest.h b/gcc/selftest.h
index 1abec2d..20d522a 100644
--- a/gcc/selftest.h
+++ b/gcc/selftest.h
@@ -244,6 +244,7 @@ extern void predict_cc_tests ();
 extern void pretty_print_cc_tests ();
 extern void range_tests ();
 extern void range_op_tests ();
+extern void relation_tests ();
 extern void gimple_range_tests ();
 extern void read_rtl_function_cc_tests ();
 extern void rtl_tests_cc_tests ();
diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index a57ad0d..7d476cc 100644
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,2022 @@
+2023-01-30  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* g++.target/riscv/rvv/base/vloxei64-1.C: New test.
+	* g++.target/riscv/rvv/base/vloxei64-2.C: New test.
+	* g++.target/riscv/rvv/base/vloxei64-3.C: New test.
+	* g++.target/riscv/rvv/base/vloxei64_mu-1.C: New test.
+	* g++.target/riscv/rvv/base/vloxei64_mu-2.C: New test.
+	* g++.target/riscv/rvv/base/vloxei64_mu-3.C: New test.
+	* g++.target/riscv/rvv/base/vloxei64_tu-1.C: New test.
+	* g++.target/riscv/rvv/base/vloxei64_tu-2.C: New test.
+	* g++.target/riscv/rvv/base/vloxei64_tu-3.C: New test.
+	* g++.target/riscv/rvv/base/vloxei64_tum-1.C: New test.
+	* g++.target/riscv/rvv/base/vloxei64_tum-2.C: New test.
+	* g++.target/riscv/rvv/base/vloxei64_tum-3.C: New test.
+	* g++.target/riscv/rvv/base/vloxei64_tumu-1.C: New test.
+	* g++.target/riscv/rvv/base/vloxei64_tumu-2.C: New test.
+	* g++.target/riscv/rvv/base/vloxei64_tumu-3.C: New test.
+
+2023-01-30  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* g++.target/riscv/rvv/base/vloxei32-1.C: New test.
+	* g++.target/riscv/rvv/base/vloxei32-2.C: New test.
+	* g++.target/riscv/rvv/base/vloxei32-3.C: New test.
+	* g++.target/riscv/rvv/base/vloxei32_mu-1.C: New test.
+	* g++.target/riscv/rvv/base/vloxei32_mu-2.C: New test.
+	* g++.target/riscv/rvv/base/vloxei32_mu-3.C: New test.
+	* g++.target/riscv/rvv/base/vloxei32_tu-1.C: New test.
+	* g++.target/riscv/rvv/base/vloxei32_tu-2.C: New test.
+	* g++.target/riscv/rvv/base/vloxei32_tu-3.C: New test.
+	* g++.target/riscv/rvv/base/vloxei32_tum-1.C: New test.
+	* g++.target/riscv/rvv/base/vloxei32_tum-2.C: New test.
+	* g++.target/riscv/rvv/base/vloxei32_tum-3.C: New test.
+	* g++.target/riscv/rvv/base/vloxei32_tumu-1.C: New test.
+	* g++.target/riscv/rvv/base/vloxei32_tumu-2.C: New test.
+	* g++.target/riscv/rvv/base/vloxei32_tumu-3.C: New test.
+
+2023-01-30  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* g++.target/riscv/rvv/base/vloxei16-1.C: New test.
+	* g++.target/riscv/rvv/base/vloxei16-2.C: New test.
+	* g++.target/riscv/rvv/base/vloxei16-3.C: New test.
+	* g++.target/riscv/rvv/base/vloxei16_mu-1.C: New test.
+	* g++.target/riscv/rvv/base/vloxei16_mu-2.C: New test.
+	* g++.target/riscv/rvv/base/vloxei16_mu-3.C: New test.
+	* g++.target/riscv/rvv/base/vloxei16_tu-1.C: New test.
+	* g++.target/riscv/rvv/base/vloxei16_tu-2.C: New test.
+	* g++.target/riscv/rvv/base/vloxei16_tu-3.C: New test.
+	* g++.target/riscv/rvv/base/vloxei16_tum-1.C: New test.
+	* g++.target/riscv/rvv/base/vloxei16_tum-2.C: New test.
+	* g++.target/riscv/rvv/base/vloxei16_tum-3.C: New test.
+	* g++.target/riscv/rvv/base/vloxei16_tumu-1.C: New test.
+	* g++.target/riscv/rvv/base/vloxei16_tumu-2.C: New test.
+	* g++.target/riscv/rvv/base/vloxei16_tumu-3.C: New test.
+
+2023-01-30  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* g++.target/riscv/rvv/base/vloxei8-1.C: New test.
+	* g++.target/riscv/rvv/base/vloxei8-2.C: New test.
+	* g++.target/riscv/rvv/base/vloxei8-3.C: New test.
+	* g++.target/riscv/rvv/base/vloxei8_mu-1.C: New test.
+	* g++.target/riscv/rvv/base/vloxei8_mu-2.C: New test.
+	* g++.target/riscv/rvv/base/vloxei8_mu-3.C: New test.
+	* g++.target/riscv/rvv/base/vloxei8_tu-1.C: New test.
+	* g++.target/riscv/rvv/base/vloxei8_tu-2.C: New test.
+	* g++.target/riscv/rvv/base/vloxei8_tu-3.C: New test.
+	* g++.target/riscv/rvv/base/vloxei8_tum-1.C: New test.
+	* g++.target/riscv/rvv/base/vloxei8_tum-2.C: New test.
+	* g++.target/riscv/rvv/base/vloxei8_tum-3.C: New test.
+	* g++.target/riscv/rvv/base/vloxei8_tumu-1.C: New test.
+	* g++.target/riscv/rvv/base/vloxei8_tumu-2.C: New test.
+	* g++.target/riscv/rvv/base/vloxei8_tumu-3.C: New test.
+
+2023-01-30  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* g++.target/riscv/rvv/base/vluxei64-1.C: New test.
+	* g++.target/riscv/rvv/base/vluxei64-2.C: New test.
+	* g++.target/riscv/rvv/base/vluxei64-3.C: New test.
+	* g++.target/riscv/rvv/base/vluxei64_mu-1.C: New test.
+	* g++.target/riscv/rvv/base/vluxei64_mu-2.C: New test.
+	* g++.target/riscv/rvv/base/vluxei64_mu-3.C: New test.
+	* g++.target/riscv/rvv/base/vluxei64_tu-1.C: New test.
+	* g++.target/riscv/rvv/base/vluxei64_tu-2.C: New test.
+	* g++.target/riscv/rvv/base/vluxei64_tu-3.C: New test.
+	* g++.target/riscv/rvv/base/vluxei64_tum-1.C: New test.
+	* g++.target/riscv/rvv/base/vluxei64_tum-2.C: New test.
+	* g++.target/riscv/rvv/base/vluxei64_tum-3.C: New test.
+	* g++.target/riscv/rvv/base/vluxei64_tumu-1.C: New test.
+	* g++.target/riscv/rvv/base/vluxei64_tumu-2.C: New test.
+	* g++.target/riscv/rvv/base/vluxei64_tumu-3.C: New test.
+
+2023-01-30  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* g++.target/riscv/rvv/base/vluxei32-1.C: New test.
+	* g++.target/riscv/rvv/base/vluxei32-2.C: New test.
+	* g++.target/riscv/rvv/base/vluxei32-3.C: New test.
+	* g++.target/riscv/rvv/base/vluxei32_mu-1.C: New test.
+	* g++.target/riscv/rvv/base/vluxei32_mu-2.C: New test.
+	* g++.target/riscv/rvv/base/vluxei32_mu-3.C: New test.
+	* g++.target/riscv/rvv/base/vluxei32_tu-1.C: New test.
+	* g++.target/riscv/rvv/base/vluxei32_tu-2.C: New test.
+	* g++.target/riscv/rvv/base/vluxei32_tu-3.C: New test.
+	* g++.target/riscv/rvv/base/vluxei32_tum-1.C: New test.
+	* g++.target/riscv/rvv/base/vluxei32_tum-2.C: New test.
+	* g++.target/riscv/rvv/base/vluxei32_tum-3.C: New test.
+	* g++.target/riscv/rvv/base/vluxei32_tumu-1.C: New test.
+	* g++.target/riscv/rvv/base/vluxei32_tumu-2.C: New test.
+	* g++.target/riscv/rvv/base/vluxei32_tumu-3.C: New test.
+
+2023-01-30  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* g++.target/riscv/rvv/base/vluxei16-1.C: New test.
+	* g++.target/riscv/rvv/base/vluxei16-2.C: New test.
+	* g++.target/riscv/rvv/base/vluxei16-3.C: New test.
+	* g++.target/riscv/rvv/base/vluxei16_mu-1.C: New test.
+	* g++.target/riscv/rvv/base/vluxei16_mu-2.C: New test.
+	* g++.target/riscv/rvv/base/vluxei16_mu-3.C: New test.
+	* g++.target/riscv/rvv/base/vluxei16_tu-1.C: New test.
+	* g++.target/riscv/rvv/base/vluxei16_tu-2.C: New test.
+	* g++.target/riscv/rvv/base/vluxei16_tu-3.C: New test.
+	* g++.target/riscv/rvv/base/vluxei16_tum-1.C: New test.
+	* g++.target/riscv/rvv/base/vluxei16_tum-2.C: New test.
+	* g++.target/riscv/rvv/base/vluxei16_tum-3.C: New test.
+	* g++.target/riscv/rvv/base/vluxei16_tumu-1.C: New test.
+	* g++.target/riscv/rvv/base/vluxei16_tumu-2.C: New test.
+	* g++.target/riscv/rvv/base/vluxei16_tumu-3.C: New test.
+
+2023-01-30  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* g++.target/riscv/rvv/base/vluxei8-1.C: New test.
+	* g++.target/riscv/rvv/base/vluxei8-2.C: New test.
+	* g++.target/riscv/rvv/base/vluxei8-3.C: New test.
+	* g++.target/riscv/rvv/base/vluxei8_mu-1.C: New test.
+	* g++.target/riscv/rvv/base/vluxei8_mu-2.C: New test.
+	* g++.target/riscv/rvv/base/vluxei8_mu-3.C: New test.
+	* g++.target/riscv/rvv/base/vluxei8_tu-1.C: New test.
+	* g++.target/riscv/rvv/base/vluxei8_tu-2.C: New test.
+	* g++.target/riscv/rvv/base/vluxei8_tu-3.C: New test.
+	* g++.target/riscv/rvv/base/vluxei8_tum-1.C: New test.
+	* g++.target/riscv/rvv/base/vluxei8_tum-2.C: New test.
+	* g++.target/riscv/rvv/base/vluxei8_tum-3.C: New test.
+	* g++.target/riscv/rvv/base/vluxei8_tumu-1.C: New test.
+	* g++.target/riscv/rvv/base/vluxei8_tumu-2.C: New test.
+	* g++.target/riscv/rvv/base/vluxei8_tumu-3.C: New test.
+
+2023-01-30  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* g++.target/riscv/rvv/base/vsuxei16-1.C: New test.
+	* g++.target/riscv/rvv/base/vsuxei16-2.C: New test.
+	* g++.target/riscv/rvv/base/vsuxei16-3.C: New test.
+	* g++.target/riscv/rvv/base/vsuxei32-1.C: New test.
+	* g++.target/riscv/rvv/base/vsuxei32-2.C: New test.
+	* g++.target/riscv/rvv/base/vsuxei32-3.C: New test.
+	* g++.target/riscv/rvv/base/vsuxei64-1.C: New test.
+	* g++.target/riscv/rvv/base/vsuxei64-2.C: New test.
+	* g++.target/riscv/rvv/base/vsuxei64-3.C: New test.
+	* g++.target/riscv/rvv/base/vsuxei8-1.C: New test.
+	* g++.target/riscv/rvv/base/vsuxei8-2.C: New test.
+	* g++.target/riscv/rvv/base/vsuxei8-3.C: New test.
+
+2023-01-30  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* gcc.target/riscv/rvv/base/vsuxei16_v-1.c: New test.
+	* gcc.target/riscv/rvv/base/vsuxei16_v-2.c: New test.
+	* gcc.target/riscv/rvv/base/vsuxei16_v-3.c: New test.
+	* gcc.target/riscv/rvv/base/vsuxei16_v_m-1.c: New test.
+	* gcc.target/riscv/rvv/base/vsuxei16_v_m-2.c: New test.
+	* gcc.target/riscv/rvv/base/vsuxei16_v_m-3.c: New test.
+	* gcc.target/riscv/rvv/base/vsuxei32_v-1.c: New test.
+	* gcc.target/riscv/rvv/base/vsuxei32_v-2.c: New test.
+	* gcc.target/riscv/rvv/base/vsuxei32_v-3.c: New test.
+	* gcc.target/riscv/rvv/base/vsuxei32_v_m-1.c: New test.
+	* gcc.target/riscv/rvv/base/vsuxei32_v_m-2.c: New test.
+	* gcc.target/riscv/rvv/base/vsuxei32_v_m-3.c: New test.
+	* gcc.target/riscv/rvv/base/vsuxei64_v-1.c: New test.
+	* gcc.target/riscv/rvv/base/vsuxei64_v-2.c: New test.
+	* gcc.target/riscv/rvv/base/vsuxei64_v-3.c: New test.
+	* gcc.target/riscv/rvv/base/vsuxei64_v_m-1.c: New test.
+	* gcc.target/riscv/rvv/base/vsuxei64_v_m-2.c: New test.
+	* gcc.target/riscv/rvv/base/vsuxei64_v_m-3.c: New test.
+	* gcc.target/riscv/rvv/base/vsuxei8_v-1.c: New test.
+	* gcc.target/riscv/rvv/base/vsuxei8_v-2.c: New test.
+	* gcc.target/riscv/rvv/base/vsuxei8_v-3.c: New test.
+	* gcc.target/riscv/rvv/base/vsuxei8_v_m-1.c: New test.
+	* gcc.target/riscv/rvv/base/vsuxei8_v_m-2.c: New test.
+	* gcc.target/riscv/rvv/base/vsuxei8_v_m-3.c: New test.
+
+2023-01-30  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* gcc.target/riscv/rvv/base/vsoxei16_v-1.c: New test.
+	* gcc.target/riscv/rvv/base/vsoxei16_v-2.c: New test.
+	* gcc.target/riscv/rvv/base/vsoxei16_v-3.c: New test.
+	* gcc.target/riscv/rvv/base/vsoxei16_v_m-1.c: New test.
+	* gcc.target/riscv/rvv/base/vsoxei16_v_m-2.c: New test.
+	* gcc.target/riscv/rvv/base/vsoxei16_v_m-3.c: New test.
+	* gcc.target/riscv/rvv/base/vsoxei32_v-1.c: New test.
+	* gcc.target/riscv/rvv/base/vsoxei32_v-2.c: New test.
+	* gcc.target/riscv/rvv/base/vsoxei32_v-3.c: New test.
+	* gcc.target/riscv/rvv/base/vsoxei32_v_m-1.c: New test.
+	* gcc.target/riscv/rvv/base/vsoxei32_v_m-2.c: New test.
+	* gcc.target/riscv/rvv/base/vsoxei32_v_m-3.c: New test.
+	* gcc.target/riscv/rvv/base/vsoxei64_v-1.c: New test.
+	* gcc.target/riscv/rvv/base/vsoxei64_v-2.c: New test.
+	* gcc.target/riscv/rvv/base/vsoxei64_v-3.c: New test.
+	* gcc.target/riscv/rvv/base/vsoxei64_v_m-1.c: New test.
+	* gcc.target/riscv/rvv/base/vsoxei64_v_m-2.c: New test.
+	* gcc.target/riscv/rvv/base/vsoxei64_v_m-3.c: New test.
+	* gcc.target/riscv/rvv/base/vsoxei8_v-1.c: New test.
+	* gcc.target/riscv/rvv/base/vsoxei8_v-2.c: New test.
+	* gcc.target/riscv/rvv/base/vsoxei8_v-3.c: New test.
+	* gcc.target/riscv/rvv/base/vsoxei8_v_m-1.c: New test.
+	* gcc.target/riscv/rvv/base/vsoxei8_v_m-2.c: New test.
+	* gcc.target/riscv/rvv/base/vsoxei8_v_m-3.c: New test.
+
+2023-01-30  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* g++.target/riscv/rvv/base/vsoxei32-1.C: New test.
+	* g++.target/riscv/rvv/base/vsoxei32-2.C: New test.
+	* g++.target/riscv/rvv/base/vsoxei32-3.C: New test.
+	* g++.target/riscv/rvv/base/vsoxei64-1.C: New test.
+	* g++.target/riscv/rvv/base/vsoxei64-2.C: New test.
+	* g++.target/riscv/rvv/base/vsoxei64-3.C: New test.
+
+2023-01-30  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* g++.target/riscv/rvv/base/vsoxei16-1.C: New test.
+	* g++.target/riscv/rvv/base/vsoxei16-2.C: New test.
+	* g++.target/riscv/rvv/base/vsoxei16-3.C: New test.
+	* g++.target/riscv/rvv/base/vsoxei8-1.C: New test.
+	* g++.target/riscv/rvv/base/vsoxei8-2.C: New test.
+	* g++.target/riscv/rvv/base/vsoxei8-3.C: New test.
+
+2023-01-30  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* gcc.target/riscv/rvv/base/vluxei64_v-1.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei64_v-2.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei64_v-3.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei64_v_m-1.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei64_v_m-2.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei64_v_m-3.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei64_v_mu-1.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei64_v_mu-2.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei64_v_mu-3.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei64_v_tu-1.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei64_v_tu-2.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei64_v_tu-3.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei64_v_tum-1.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei64_v_tum-2.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei64_v_tum-3.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei64_v_tumu-1.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei64_v_tumu-2.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei64_v_tumu-3.c: New test.
+
+2023-01-30  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* gcc.target/riscv/rvv/base/vluxei32_v-1.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei32_v-2.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei32_v-3.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei32_v_m-1.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei32_v_m-2.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei32_v_m-3.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei32_v_mu-1.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei32_v_mu-2.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei32_v_mu-3.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei32_v_tu-1.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei32_v_tu-2.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei32_v_tu-3.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei32_v_tum-1.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei32_v_tum-2.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei32_v_tum-3.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei32_v_tumu-1.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei32_v_tumu-2.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei32_v_tumu-3.c: New test.
+
+2023-01-30  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* gcc.target/riscv/rvv/base/vluxei16_v-1.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei16_v-2.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei16_v-3.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei16_v_m-1.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei16_v_m-2.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei16_v_m-3.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei16_v_mu-1.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei16_v_mu-2.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei16_v_mu-3.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei16_v_tu-1.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei16_v_tu-2.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei16_v_tu-3.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei16_v_tum-1.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei16_v_tum-2.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei16_v_tum-3.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei16_v_tumu-1.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei16_v_tumu-2.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei16_v_tumu-3.c: New test.
+
+2023-01-30  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* gcc.target/riscv/rvv/base/vluxei8_v-1.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei8_v-2.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei8_v-3.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei8_v_m-1.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei8_v_m-2.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei8_v_m-3.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei8_v_mu-1.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei8_v_mu-2.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei8_v_mu-3.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei8_v_tu-1.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei8_v_tu-2.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei8_v_tu-3.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei8_v_tum-1.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei8_v_tum-2.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei8_v_tum-3.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei8_v_tumu-1.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei8_v_tumu-2.c: New test.
+	* gcc.target/riscv/rvv/base/vluxei8_v_tumu-3.c: New test.
+
+2023-01-30  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* gcc.target/riscv/rvv/base/vloxei64_v-1.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei64_v-2.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei64_v-3.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei64_v_m-1.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei64_v_m-2.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei64_v_m-3.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei64_v_mu-1.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei64_v_mu-2.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei64_v_mu-3.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei64_v_tu-1.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei64_v_tu-2.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei64_v_tu-3.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei64_v_tum-1.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei64_v_tum-2.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei64_v_tum-3.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei64_v_tumu-1.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei64_v_tumu-2.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei64_v_tumu-3.c: New test.
+
+2023-01-30  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* gcc.target/riscv/rvv/base/vloxei32_v-1.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei32_v-2.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei32_v-3.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei32_v_m-1.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei32_v_m-2.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei32_v_m-3.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei32_v_mu-1.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei32_v_mu-2.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei32_v_mu-3.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei32_v_tu-1.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei32_v_tu-2.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei32_v_tu-3.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei32_v_tum-1.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei32_v_tum-2.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei32_v_tum-3.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei32_v_tumu-1.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei32_v_tumu-2.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei32_v_tumu-3.c: New test.
+
+2023-01-30  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* gcc.target/riscv/rvv/base/vloxei16_v-1.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei16_v-2.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei16_v-3.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei16_v_m-1.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei16_v_m-2.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei16_v_m-3.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei16_v_mu-1.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei16_v_mu-2.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei16_v_mu-3.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei16_v_tu-1.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei16_v_tu-2.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei16_v_tu-3.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei16_v_tum-1.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei16_v_tum-2.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei16_v_tum-3.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei16_v_tumu-1.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei16_v_tumu-2.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei16_v_tumu-3.c: New test.
+
+2023-01-30  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* gcc.target/riscv/rvv/base/vloxei8_v-1.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei8_v-2.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei8_v-3.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei8_v_m-1.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei8_v_m-2.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei8_v_m-3.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei8_v_mu-1.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei8_v_mu-2.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei8_v_mu-3.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei8_v_tu-1.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei8_v_tu-2.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei8_v_tu-3.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei8_v_tum-1.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei8_v_tum-2.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei8_v_tum-3.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei8_v_tumu-1.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei8_v_tumu-2.c: New test.
+	* gcc.target/riscv/rvv/base/vloxei8_v_tumu-3.c: New test.
+
+2023-01-30  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* gcc.target/riscv/rvv/base/vlxei-vsxei-constraint-1.c: New test.
+
+2023-01-30  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* gcc.target/riscv/rvv/vsetvl/avl_single-72.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-76.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-77.c: New test.
+
+2023-01-30  Rainer Orth  <ro@CeBiTec.Uni-Bielefeld.DE>
+
+	* gm2/warnings/returntype/fail/warnings-returntype-fail.exp: Save,
+	restore TORTURE_OPTIONS.
+
+2023-01-30  Andrew Pinski  <apinski@marvell.com>
+
+	PR tree-optimization/108582
+	* gcc.dg/pr108582-1.c: New test.
+
+2023-01-30  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/108574
+	* gcc.dg/torture/pr108574-1.c: New testcase.
+	* gcc.dg/torture/pr108574-2.c: Likewise.
+	* gcc.dg/torture/pr108574-3.c: Likewise.
+
+2023-01-29  Mikael Morin  <mikael@gcc.gnu.org>
+
+	PR fortran/108450
+	* gfortran.dg/gomp/minmaxloc_1.f90: New test.
+
+2023-01-29  Jerry DeLisle  <jvdelisle@gcc.gnu.org>
+
+	PR fortran/103506
+	* gfortran.dg/pr103506_1.f90: New test.
+
+2023-01-29  Jan Hubicka  <hubicka@ucw.cz>
+
+	* gcc.dg/ipa/ipa-sra-30.c: New test.
+	* gcc.dg/ipa/ipa-sra-31.c: New test.
+	* gcc.dg/tree-ssa/modref-dse-7.c: New test.
+
+2023-01-28  Harald Anlauf  <anlauf@gmx.de>
+	    Steven G. Kargl  <kargl@gcc.gnu.org>
+
+	PR fortran/108527
+	* gfortran.dg/pr108527.f90: New test.
+
+2023-01-28  Harald Anlauf  <anlauf@gmx.de>
+
+	PR fortran/108453
+	* gfortran.dg/common_27.f90: New test.
+
+2023-01-28  Jonathan Yong  <10walls@gmail.com>
+
+	PR c/108192
+	* g++.dg/cet-notrack-1.C: Use puts instead of printf,
+	so function call is not mangled by __mingw_printf when
+	doing assembly symbol inspection.
+
+2023-01-28  Jonathan Yong  <10walls@gmail.com>
+
+	PR c/108150
+	* gcc.dg/attr-aligned.c: Make errors emitted on Windows
+	target same as on Linux.
+
+2023-01-28  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* g++.target/riscv/rvv/base/vlse-1.C: New test.
+	* g++.target/riscv/rvv/base/vlse_tu-1.C: New test.
+	* g++.target/riscv/rvv/base/vlse_tum-1.C: New test.
+	* g++.target/riscv/rvv/base/vlse_tumu-1.C: New test.
+	* g++.target/riscv/rvv/base/vsse-1.C: New test.
+	* gcc.target/riscv/rvv/base/vlse-1.c: New test.
+	* gcc.target/riscv/rvv/base/vlse-2.c: New test.
+	* gcc.target/riscv/rvv/base/vlse-3.c: New test.
+	* gcc.target/riscv/rvv/base/vlse-vsse-constraint-1.c: New test.
+	* gcc.target/riscv/rvv/base/vlse_m-1.c: New test.
+	* gcc.target/riscv/rvv/base/vlse_m-2.c: New test.
+	* gcc.target/riscv/rvv/base/vlse_m-3.c: New test.
+	* gcc.target/riscv/rvv/base/vlse_mu-1.c: New test.
+	* gcc.target/riscv/rvv/base/vlse_mu-2.c: New test.
+	* gcc.target/riscv/rvv/base/vlse_mu-3.c: New test.
+	* gcc.target/riscv/rvv/base/vlse_tu-1.c: New test.
+	* gcc.target/riscv/rvv/base/vlse_tu-2.c: New test.
+	* gcc.target/riscv/rvv/base/vlse_tu-3.c: New test.
+	* gcc.target/riscv/rvv/base/vlse_tum-1.c: New test.
+	* gcc.target/riscv/rvv/base/vlse_tum-2.c: New test.
+	* gcc.target/riscv/rvv/base/vlse_tum-3.c: New test.
+	* gcc.target/riscv/rvv/base/vlse_tumu-1.c: New test.
+	* gcc.target/riscv/rvv/base/vlse_tumu-2.c: New test.
+	* gcc.target/riscv/rvv/base/vlse_tumu-3.c: New test.
+	* gcc.target/riscv/rvv/base/vsse-1.c: New test.
+	* gcc.target/riscv/rvv/base/vsse-2.c: New test.
+	* gcc.target/riscv/rvv/base/vsse-3.c: New test.
+	* gcc.target/riscv/rvv/base/vsse_m-1.c: New test.
+	* gcc.target/riscv/rvv/base/vsse_m-2.c: New test.
+	* gcc.target/riscv/rvv/base/vsse_m-3.c: New test.
+
+2023-01-28  Jerry DeLisle  <jvdelisle@gcc.gnu.org>
+
+	* gfortran.dg/ISO_Fortran_binding_17.f90: Replace (\n|\r\n|\r)
+	with (\r*\n+).
+	* gfortran.dg/array_temporaries_2.f90: Likewise.
+	* gfortran.dg/bind-c-contiguous-1.f90: Likewise.
+	* gfortran.dg/bind-c-contiguous-4.f90: Likewise.
+	* gfortran.dg/bind-c-contiguous-5.f90: Likewise.
+	* gfortran.dg/fmt_error_4.f90: Likewise.
+	* gfortran.dg/fmt_error_5.f90: Likewise.
+	* gfortran.dg/fmt_float.f90: Likewise.
+	* gfortran.dg/fmt_l.f90: Likewise.
+	* gfortran.dg/fmt_nonchar_2.f90: Likewise.
+	* gfortran.dg/fmt_zero_precision.f90: Likewise.
+	* gfortran.dg/g77/f77-edit-apostrophe-out.f: Likewise.
+	* gfortran.dg/g77/f77-edit-colon-out.f: Likewise.
+	* gfortran.dg/g77/f77-edit-h-out.f: Likewise.
+	* gfortran.dg/g77/f77-edit-i-out.f: Likewise.
+	* gfortran.dg/g77/f77-edit-s-out.f: Likewise.
+	* gfortran.dg/g77/f77-edit-slash-out.f: Likewise.
+	* gfortran.dg/g77/f77-edit-t-out.f: Likewise.
+	* gfortran.dg/g77/f77-edit-x-out.f: Likewise.
+	* gfortran.dg/namelist_40.f90: Likewise.
+	* gfortran.dg/namelist_47.f90: Likewise.
+	* gfortran.dg/namelist_print_1.f: Likewise.
+	* gfortran.dg/parameter_array_dummy.f90: Likewise.
+
+2023-01-27  Gaius Mulley  <gaiusmod2@gmail.com>
+
+	* gm2/pim/fail/empty.mod: New test.
+
+2023-01-27  Joseph Myers  <joseph@codesourcery.com>
+
+	* gcc.dg/c2x-auto-1.c, gcc.dg/c2x-auto-3.c: Expect braces around
+	auto initializers to be disallowed.
+
+2023-01-27  Richard Sandiford  <richard.sandiford@arm.com>
+
+	* gcc.dg/vect/complex/fast-math-bb-slp-complex-add-pattern-half-float.c:
+	Remove XFAIL.
+	* gcc.dg/vect/complex/fast-math-complex-add-half-float.c: Fix names
+	of dump files.
+
+2023-01-27  Richard Sandiford  <richard.sandiford@arm.com>
+
+	* gcc.target/aarch64/simd/vfma_f64.c: Use a wrapper function
+	rather than an asm barrier.
+	* gcc.target/aarch64/simd/vfms_f64.c: Likewise.
+	* gcc.target/aarch64/simd/vmul_f64_1.c: Use a wrapper function
+	rather than volatile.
+	* gcc.target/aarch64/simd/vmul_n_f64_1.c: Likewise.
+	* gcc.target/aarch64/simd/vqdmlalh_laneq_s16_1.c: Use a wrapper
+	function.  Remove -fno-inline.
+	* gcc.target/aarch64/simd/vqdmlals_laneq_s32_1.c: Likewise.
+	* gcc.target/aarch64/simd/vqdmlslh_laneq_s16_1.c: Likewise.
+	* gcc.target/aarch64/simd/vqdmlsls_laneq_s32_1.c: Likewise.
+	* gcc.target/aarch64/simd/vqdmulhh_lane_s16.c: Likewise.
+	* gcc.target/aarch64/simd/vqdmulhh_laneq_s16_1.c: Likewise.
+	* gcc.target/aarch64/simd/vqdmulhs_laneq_s32_1.c: Likewise.
+	* gcc.target/aarch64/simd/vqrdmulhh_lane_s16.c: Likewise.
+	* gcc.target/aarch64/simd/vqrdmulhh_laneq_s16_1.c: Likewise.
+	* gcc.target/aarch64/simd/vqrdmulhs_lane_s32.c: Likewise.
+	* gcc.target/aarch64/simd/vqrdmulhs_laneq_s32_1.c: Likewise.
+	* gcc.target/aarch64/simd/vqdmulhs_lane_s32.c: Likewise.
+	Allow the scalar form to be used when operating on lane 0.
+	Add a test for lane 1.
+
+2023-01-27  Richard Sandiford  <richard.sandiford@arm.com>
+
+	PR tree-optimization/96373
+	* gcc.target/aarch64/sve/cond_xorsign_1.c: New test.
+	* gcc.target/aarch64/sve/cond_xorsign_2.c: Likewise.
+
+2023-01-27  Richard Sandiford  <richard.sandiford@arm.com>
+
+	* gcc.target/aarch64/sve/cond_asrd_1.c: Tune for a 256-bit
+	vector length.
+	* gcc.target/aarch64/sve/cond_cnot_4.c: Likewise.
+	* gcc.target/aarch64/sve/cond_cnot_6.c: Likewise.
+	* gcc.target/aarch64/sve/cond_unary_5.c: Likewise.
+	* gcc.target/aarch64/sve/cond_unary_6.c: Likewise.
+	* gcc.target/aarch64/sve/cond_uxt_5.c: Likewise.
+	* gcc.target/aarch64/sve/vcond_4_costly.c: Remove XFAILs.
+
+2023-01-27  Andrew MacLeod  <amacleod@redhat.com>
+
+	PR tree-optimization/108306
+	* gcc.dg/pr108306.c: New.
+
+2023-01-27  Andrew MacLeod  <amacleod@redhat.com>
+
+	PR tree-optimization/108447
+	* gcc.dg/pr108447.c: New.
+
+2023-01-27  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* gcc.target/riscv/rvv/vsetvl/avl_multiple-7.c: Fix testcase check.
+	* gcc.target/riscv/rvv/vsetvl/avl_multiple-8.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vsetvl-18.c: Ditto.
+
+2023-01-27  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* g++.target/riscv/rvv/base/vle-1.C: New test.
+	* g++.target/riscv/rvv/base/vle_tu-1.C: New test.
+	* g++.target/riscv/rvv/base/vle_tum-1.C: New test.
+	* g++.target/riscv/rvv/base/vle_tumu-1.C: New test.
+	* g++.target/riscv/rvv/base/vse-1.C: New test.
+	* g++.target/riscv/rvv/base/riscv_vector.h: New.
+
+2023-01-27  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* gcc.target/riscv/rvv/base/vse-1.c: New test.
+	* gcc.target/riscv/rvv/base/vse-2.c: New test.
+	* gcc.target/riscv/rvv/base/vse-3.c: New test.
+	* gcc.target/riscv/rvv/base/vse_m-1.c: New test.
+	* gcc.target/riscv/rvv/base/vse_m-2.c: New test.
+	* gcc.target/riscv/rvv/base/vse_m-3.c: New test.
+
+2023-01-27  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* gcc.target/riscv/rvv/base/vle-1.c: New test.
+	* gcc.target/riscv/rvv/base/vle-2.c: New test.
+	* gcc.target/riscv/rvv/base/vle-3.c: New test.
+	* gcc.target/riscv/rvv/base/vle_m-1.c: New test.
+	* gcc.target/riscv/rvv/base/vle_m-2.c: New test.
+	* gcc.target/riscv/rvv/base/vle_m-3.c: New test.
+	* gcc.target/riscv/rvv/base/vle_mu-1.c: New test.
+	* gcc.target/riscv/rvv/base/vle_mu-2.c: New test.
+	* gcc.target/riscv/rvv/base/vle_mu-3.c: New test.
+	* gcc.target/riscv/rvv/base/vle_tu-1.c: New test.
+	* gcc.target/riscv/rvv/base/vle_tu-2.c: New test.
+	* gcc.target/riscv/rvv/base/vle_tu-3.c: New test.
+	* gcc.target/riscv/rvv/base/vle_tum-1.c: New test.
+	* gcc.target/riscv/rvv/base/vle_tum-2.c: New test.
+	* gcc.target/riscv/rvv/base/vle_tum-3.c: New test.
+	* gcc.target/riscv/rvv/base/vle_tumu-1.c: New test.
+	* gcc.target/riscv/rvv/base/vle_tumu-2.c: New test.
+	* gcc.target/riscv/rvv/base/vle_tumu-3.c: New test.
+
+2023-01-27  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* g++.target/riscv/rvv/base/vsm-1.C: New test.
+	* g++.target/riscv/rvv/rvv.exp: New test.
+	* gcc.target/riscv/rvv/base/vlm_vsm-1.c: New test.
+	* gcc.target/riscv/rvv/base/vlm_vsm-2.c: New test.
+	* gcc.target/riscv/rvv/base/vlm_vsm-3.c: New test.
+
+2023-01-27  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* gcc.target/riscv/rvv/vsetvl/avl_single-14.c: Adjust for final implementation.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-23.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-30.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-44.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-47.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-50.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-51.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-6.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-65.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-66.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-67.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-68.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-70.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-71.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-9.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/imm_bb_prop-2.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/imm_bb_prop-3.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/imm_bb_prop-4.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/imm_conflict-4.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/imm_conflict-5.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_back_prop-13.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-13.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-14.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-15.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-16.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-21.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-22.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-23.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-24.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-5.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-6.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-7.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-8.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_conflict-1.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_conflict-6.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-1.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-10.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-11.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-12.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-13.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-14.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-2.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-3.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-4.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-5.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-6.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-7.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-8.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-9.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_switch_vtype-10.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/avl_multiple-1.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_multiple-10.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_multiple-11.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_multiple-12.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_multiple-13.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_multiple-14.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_multiple-15.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_multiple-16.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_multiple-2.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_multiple-3.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_multiple-4.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_multiple-5.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_multiple-6.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_multiple-7.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_multiple-8.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_multiple-9.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-73.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-74.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-75.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvl-1.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvl-10.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvl-11.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvl-12.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvl-13.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvl-14.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvl-15.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvl-16.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvl-17.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvl-18.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvl-19.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvl-2.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvl-20.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvl-3.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvl-4.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvl-5.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvl-6.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvl-7.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvl-8.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvl-9.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvlmax-1.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvlmax-10.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvlmax-11.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvlmax-12.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvlmax-13.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvlmax-14.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvlmax-15.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvlmax-16.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvlmax-17.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvlmax-18.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvlmax-19.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvlmax-2.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvlmax-20.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvlmax-3.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvlmax-4.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvlmax-5.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvlmax-6.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvlmax-7.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvlmax-8.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/vsetvlmax-9.c: New test.
+
+2023-01-27  Xi Ruoyao  <xry111@xry111.site>
+
+	* gcc.dg/pr95115.c (x): Add noipa attribute.
+
+2023-01-27  Jakub Jelinek  <jakub@redhat.com>
+
+	PR ipa/106061
+	* gcc.dg/pr106061.c: New test.
+
+2023-01-27  Tobias Burnus  <tobias@codesourcery.com>
+
+	* gfortran.dg/gomp/declare-variant-10.f90: Update scan-tree's
+	target selector to handle Windows.
+	* gfortran.dg/gomp/declare-variant-11.f90: Likewise.
+	* gfortran.dg/gomp/declare-variant-12.f90: Likewise.
+
+2023-01-26  Gaius Mulley  <gaiusmod2@gmail.com>
+
+	* gm2/warnings/returntype/fail/badreturn.mod: New test.
+	* gm2/warnings/returntype/fail/warnings-returntype-fail.exp:
+	New test.
+	* gm2/warnings/returntype/pass/Termbase.mod: New test.
+	* gm2/warnings/returntype/pass/goodreturn.mod: New test.
+	* gm2/warnings/returntype/pass/keypressedsimple.mod: New test.
+	* gm2/warnings/returntype/pass/warnings-returntype-pass.exp:
+	New test.
+
+2023-01-26  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* gcc.target/riscv/rvv/vsetvl/avl_single-2.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-20.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-21.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-22.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-23.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-24.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-25.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-26.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-27.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-28.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-29.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-3.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-30.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-31.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-32.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-33.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-34.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-35.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-36.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-37.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-38.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-39.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-4.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-40.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-41.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-42.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-43.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-44.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-45.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-46.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-47.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-48.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-49.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-5.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-50.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-51.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-52.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-53.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-54.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-55.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-56.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-57.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-58.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-59.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-6.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-60.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-61.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-62.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-63.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-64.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-65.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-66.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-67.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-68.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-69.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-1.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-10.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-11.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-12.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-13.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-14.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-15.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-16.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-17.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-18.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-19.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-7.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-70.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-71.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-8.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/avl_single-9.c: New test.
+
+2023-01-26  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* gcc.target/riscv/rvv/vsetvl/imm_bb_prop-1.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_bb_prop-10.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_bb_prop-11.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_bb_prop-12.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_bb_prop-13.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_bb_prop-2.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_bb_prop-3.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_bb_prop-4.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_bb_prop-5.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_bb_prop-6.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_bb_prop-7.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_bb_prop-8.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_bb_prop-9.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_conflict-1.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_conflict-2.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_conflict-3.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_conflict-4.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_conflict-5.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-1.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-10.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-11.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-12.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-13.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-14.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-15.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-16.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-17.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-2.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-3.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-4.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-5.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-6.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-7.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-8.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-9.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_switch-1.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_switch-2.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_switch-3.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_switch-4.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_switch-5.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_switch-6.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_switch-7.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_switch-8.c: New test.
+	* gcc.target/riscv/rvv/vsetvl/imm_switch-9.c: New test.
+
+2023-01-26  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* gcc.target/riscv/rvv/vsetvl/vlmax_back_prop-27.c: Update
+	testcase.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_back_prop-28.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_back_prop-45.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-25.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-26.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-27.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-28.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-3.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_conflict-7.c: Ditto.
+	* gcc.target/riscv/rvv/vsetvl/vlmax_switch_vtype-12.c: Ditto.
+
+2023-01-26  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* gcc.target/riscv/rvv/base/vle-constraint-1.c:
+
+2023-01-26  Ju-Zhe Zhong  <juzhe.zhong@rivai.ai>
+
+	* gcc.target/riscv/rvv/base/vse-constraint-1.c: New test.
+
+2023-01-26  Harald Anlauf  <anlauf@gmx.de>
+
+	PR fortran/108544
+	* gfortran.dg/pr108544.f90: New test.
+	* gfortran.dg/pr96102b.f90: New test.
+
+2023-01-26  Marek Polacek  <polacek@redhat.com>
+
+	PR middle-end/108543
+	* c-c++-common/asan/pointer-subtract-5.c: New test.
+	* c-c++-common/asan/pointer-subtract-6.c: New test.
+	* c-c++-common/asan/pointer-subtract-7.c: New test.
+	* c-c++-common/asan/pointer-subtract-8.c: New test.
+
+2023-01-26  Jakub Jelinek  <jakub@redhat.com>
+
+	PR tree-optimization/108540
+	* gcc.c-torture/execute/ieee/pr108540-1.c: New test.
+	* gcc.c-torture/execute/ieee/pr108540-2.c: New test.
+
+2023-01-26  Richard Sandiford  <richard.sandiford@arm.com>
+
+	* c-c++-common/hwasan/arguments-3.c: Remove extraneous .*s.
+
+2023-01-26  Richard Sandiford  <richard.sandiford@arm.com>
+
+	* gcc.target/aarch64/bfloat16_scalar_typecheck.c: Accept empty
+	compound literals.
+
+2023-01-26  Richard Sandiford  <richard.sandiford@arm.com>
+
+	* gcc.dg/guality/pr36728-2.c: Update XFAILs for aarch64*-*-*.
+	* gcc.dg/guality/pr54519-1.c: Likewise.
+	* gcc.dg/guality/pr54519-3.c: Likewise.
+	* gcc.dg/guality/pr54693-2.c: Likewise.
+	* gcc.dg/guality/sra-1.c: Likewise.
+
+2023-01-26  Richard Sandiford  <richard.sandiford@arm.com>
+
+	* g++.target/aarch64/sve/pr99766.C: Disable warnings.
+
+2023-01-26  Richard Sandiford  <richard.sandiford@arm.com>
+
+	* gcc.target/aarch64/sve/slp_13.c: Remove XFAILs.
+
+2023-01-26  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/105300
+	* g++.dg/cpp0x/udlit-error1.C: New test.
+
+2023-01-26  David Malcolm  <dmalcolm@redhat.com>
+
+	PR analyzer/108507
+	* gcc.dg/analyzer/SARD-tc841-basic-00182-min.c: Add
+	-Wno-stringop-overflow.
+
+2023-01-26  David Malcolm  <dmalcolm@redhat.com>
+
+	PR analyzer/108524
+	* gcc.dg/analyzer/infinite-recursion-pr108524-1.c: New test.
+	* gcc.dg/analyzer/infinite-recursion-pr108524-2.c: New test.
+	* gcc.dg/analyzer/infinite-recursion-pr108524-qobject-json-parser.c:
+	New test.
+
+2023-01-26  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/108547
+	* gcc.dg/uninit-pr108547.c: New testcase.
+
+2023-01-26  Siddhesh Poyarekar  <siddhesh@gotplt.org>
+
+	PR tree-optimization/108522
+	* gcc.dg/builtin-dynamic-object-size-0.c (DEFSTRUCT): New
+	macro.
+	(test_dynarray_struct_member_b, test_dynarray_struct_member_c,
+	test_dynarray_struct_member_d,
+	test_dynarray_struct_member_subobj_b,
+	test_dynarray_struct_member_subobj_c,
+	test_dynarray_struct_member_subobj_d): New tests.
+	(main): Call them.
+
+2023-01-26  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/108503
+	* g++.dg/gomp/pr108503.C: New test.
+
+2023-01-26  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/108523
+	* gcc.dg/torture/pr108523.c: New testcase.
+
+2023-01-25  Steve Kargl  <kargl@gcc.gnu.org>
+
+	PR fortran/108528
+	* gfortran.dg/pr108528.f90: New test.
+
+2023-01-25  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/108525
+	* g++.dg/cpp23/static-operator-call5.C: New test.
+
+2023-01-25  Andrea Corallo  <andrea.corallo@arm.com>
+
+	* gcc.target/arm/mve/intrinsics/vhaddq_n_s16.c: Add missing extern
+	"C".
+	* gcc.target/arm/mve/intrinsics/vhaddq_n_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhaddq_n_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhaddq_n_u16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhaddq_n_u32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhaddq_n_u8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhaddq_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhaddq_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhaddq_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhaddq_u16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhaddq_u32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhaddq_u8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhaddq_x_n_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhaddq_x_n_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhaddq_x_n_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhaddq_x_n_u16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhaddq_x_n_u32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhaddq_x_n_u8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhaddq_x_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhaddq_x_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhaddq_x_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhaddq_x_u16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhaddq_x_u32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhaddq_x_u8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhsubq_n_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhsubq_n_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhsubq_n_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhsubq_n_u16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhsubq_n_u32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhsubq_n_u8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhsubq_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhsubq_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhsubq_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhsubq_u16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhsubq_u32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhsubq_u8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhsubq_x_n_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhsubq_x_n_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhsubq_x_n_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhsubq_x_n_u16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhsubq_x_n_u32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhsubq_x_n_u8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhsubq_x_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhsubq_x_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhsubq_x_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhsubq_x_u16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhsubq_x_u32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vhsubq_x_u8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmladavaxq_p_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmladavaxq_p_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmladavaxq_p_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmladavaxq_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmladavaxq_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmladavaxq_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqaddq_n_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqaddq_n_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqaddq_n_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqaddq_n_u16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqaddq_n_u32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqaddq_n_u8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqaddq_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqaddq_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqaddq_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqaddq_u16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqaddq_u32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqaddq_u8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqdmlahq_n_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqdmlahq_n_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqdmlahq_n_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqdmlashq_m_n_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqdmlashq_m_n_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqdmlashq_m_n_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqdmlashq_n_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqdmlashq_n_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqdmlashq_n_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vsetq_lane_f16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vsetq_lane_f32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vsetq_lane_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vsetq_lane_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vsetq_lane_s64.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vsetq_lane_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vsetq_lane_u16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vsetq_lane_u32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vsetq_lane_u64.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vsetq_lane_u8.c: Likewise.
+
+2023-01-25  Andrea Corallo  <andrea.corallo@arm.com>
+
+	* gcc.target/arm/mve/intrinsics/vld2q_f16.c: Use
+	check-function-bodies instead of scan-assembler checks.  Use
+	extern "C" for C++ testing.
+	* gcc.target/arm/mve/intrinsics/vld2q_f32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vld2q_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vld2q_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vld2q_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vld2q_u16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vld2q_u32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vld2q_u8.c: Likewise.
+
+2023-01-25  Andrea Corallo  <andrea.corallo@arm.com>
+
+	* gcc.target/arm/mve/intrinsics/vqnegq_m_s16.c: Use
+	check-function-bodies instead of scan-assembler checks.  Use
+	extern "C" for C++ testing.
+	* gcc.target/arm/mve/intrinsics/vqnegq_m_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqnegq_m_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqnegq_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqnegq_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqnegq_s8.c: Likewise.
+
+2023-01-25  Andrea Corallo  <andrea.corallo@arm.com>
+
+	* gcc.target/arm/mve/intrinsics/vqrdmulhq_m_n_s16.c: Use
+	check-function-bodies instead of scan-assembler checks.  Use
+	extern "C" for C++ testing.
+	* gcc.target/arm/mve/intrinsics/vqrdmulhq_m_n_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqrdmulhq_m_n_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqrdmulhq_m_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqrdmulhq_m_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqrdmulhq_m_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqrdmulhq_n_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqrdmulhq_n_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqrdmulhq_n_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqrdmulhq_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqrdmulhq_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqrdmulhq_s8.c: Likewise.
+
+2023-01-25  Andrea Corallo  <andrea.corallo@arm.com>
+
+	* gcc.target/arm/mve/intrinsics/vqrdmlsdhxq_m_s16.c: Use
+	check-function-bodies instead of scan-assembler checks.  Use
+	extern "C" for C++ testing.
+	* gcc.target/arm/mve/intrinsics/vqrdmlsdhxq_m_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqrdmlsdhxq_m_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqrdmlsdhxq_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqrdmlsdhxq_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqrdmlsdhxq_s8.c: Likewise.
+
+2023-01-25  Andrea Corallo  <andrea.corallo@arm.com>
+
+	* gcc.target/arm/mve/intrinsics/vqrdmlsdhq_m_s16.c: Use
+	check-function-bodies instead of scan-assembler checks.  Use
+	extern "C" for C++ testing.
+	* gcc.target/arm/mve/intrinsics/vqrdmlsdhq_m_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqrdmlsdhq_m_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqrdmlsdhq_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqrdmlsdhq_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqrdmlsdhq_s8.c: Likewise.
+
+2023-01-25  Andrea Corallo  <andrea.corallo@arm.com>
+
+	* gcc.target/arm/mve/intrinsics/vqdmlsdhxq_m_s16.c: Use
+	check-function-bodies instead of scan-assembler checks.  Use
+	extern "C" for C++ testing.
+	* gcc.target/arm/mve/intrinsics/vqdmlsdhxq_m_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqdmlsdhxq_m_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqdmlsdhxq_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqdmlsdhxq_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqdmlsdhxq_s8.c: Likewise.
+
+2023-01-25  Andrea Corallo  <andrea.corallo@arm.com>
+
+	* gcc.target/arm/mve/intrinsics/vqdmlsdhq_m_s16.c: Use
+	check-function-bodies instead of scan-assembler checks.  Use
+	extern "C" for C++ testing.
+	* gcc.target/arm/mve/intrinsics/vqdmlsdhq_m_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqdmlsdhq_m_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqdmlsdhq_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqdmlsdhq_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqdmlsdhq_s8.c: Likewise.
+
+2023-01-25  Andrea Corallo  <andrea.corallo@arm.com>
+
+	* gcc.target/arm/mve/intrinsics/vqrdmlashq_n_s16.c: Use
+	check-function-bodies instead of scan-assembler checks.  Use
+	extern "C" for C++ testing.
+	* gcc.target/arm/mve/intrinsics/vqrdmlashq_n_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqrdmlashq_n_s8.c: Likewise.
+
+2023-01-25  Andrea Corallo  <andrea.corallo@arm.com>
+
+	* gcc.target/arm/mve/intrinsics/vqrdmladhxq_m_s16.c: Use
+	check-function-bodies instead of scan-assembler checks.  Use
+	extern "C" for C++ testing.
+	* gcc.target/arm/mve/intrinsics/vqrdmladhxq_m_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqrdmladhxq_m_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqrdmladhxq_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqrdmladhxq_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqrdmladhxq_s8.c: Likewise.
+
+2023-01-25  Andrea Corallo  <andrea.corallo@arm.com>
+
+	* gcc.target/arm/mve/intrinsics/vqrdmladhq_m_s16.c: Use
+	check-function-bodies instead of scan-assembler checks.  Use
+	extern "C" for C++ testing.
+	* gcc.target/arm/mve/intrinsics/vqrdmladhq_m_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqrdmladhq_m_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqrdmladhq_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqrdmladhq_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqrdmladhq_s8.c: Likewise.
+
+2023-01-25  Andrea Corallo  <andrea.corallo@arm.com>
+
+	* gcc.target/arm/mve/intrinsics/vqdmladhxq_m_s16.c: Use
+	check-function-bodies instead of scan-assembler checks.  Use
+	extern "C" for C++ testing.
+	* gcc.target/arm/mve/intrinsics/vqdmladhxq_m_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqdmladhxq_m_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqdmladhxq_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqdmladhxq_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqdmladhxq_s8.c: Likewise.
+
+2023-01-25  Andrea Corallo  <andrea.corallo@arm.com>
+
+	* gcc.target/arm/mve/intrinsics/vqdmladhq_m_s16.c: Use
+	check-function-bodies instead of scan-assembler checks.  Use
+	extern "C" for C++ testing.
+	* gcc.target/arm/mve/intrinsics/vqdmladhq_m_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqdmladhq_m_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqdmladhq_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqdmladhq_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqdmladhq_s8.c: Likewise.
+
+2023-01-25  Andrea Corallo  <andrea.corallo@arm.com>
+
+	* gcc.target/arm/mve/intrinsics/vqabsq_m_s16.c: Use
+	check-function-bodies instead of scan-assembler checks.  Use
+	extern "C" for C++ testing.
+	* gcc.target/arm/mve/intrinsics/vqabsq_m_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqabsq_m_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqabsq_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqabsq_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vqabsq_s8.c: Likewise.
+
+2023-01-25  Andrea Corallo  <andrea.corallo@arm.com>
+
+	* gcc.target/arm/mve/intrinsics/vcmulq_f16.c: Use
+	check-function-bodies instead of scan-assembler checks.  Use
+	extern "C" for C++ testing.
+	* gcc.target/arm/mve/intrinsics/vcmulq_f32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmulq_m_f16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmulq_m_f32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmulq_rot180_f16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmulq_rot180_f32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmulq_rot180_m_f16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmulq_rot180_m_f32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmulq_rot180_x_f16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmulq_rot180_x_f32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmulq_rot270_f16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmulq_rot270_f32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmulq_rot270_m_f16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmulq_rot270_m_f32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmulq_rot270_x_f16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmulq_rot270_x_f32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmulq_rot90_f16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmulq_rot90_f32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmulq_rot90_m_f16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmulq_rot90_m_f32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmulq_rot90_x_f16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmulq_rot90_x_f32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmulq_x_f16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmulq_x_f32.c: Likewise.
+
+2023-01-25  Andrea Corallo  <andrea.corallo@arm.com>
+
+	* gcc.target/arm/mve/intrinsics/vcmlaq_f16.c: Use
+	check-function-bodies instead of scan-assembler checks.  Use
+	extern "C" for C++ testing.
+	* gcc.target/arm/mve/intrinsics/vcmlaq_f32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmlaq_m_f16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmlaq_m_f32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmlaq_rot180_f16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmlaq_rot180_f32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmlaq_rot180_m_f16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmlaq_rot180_m_f32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmlaq_rot270_f16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmlaq_rot270_f32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmlaq_rot270_m_f16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmlaq_rot270_m_f32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmlaq_rot90_f16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmlaq_rot90_f32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmlaq_rot90_m_f16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcmlaq_rot90_m_f32.c: Likewise.
+
+2023-01-25  Andrea Corallo  <andrea.corallo@arm.com>
+
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot270_f16.c: Use
+	check-function-bodies instead of scan-assembler checks.  Use
+	extern "C" for C++ testing.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot270_f32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_f16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_f32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_u16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_u32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_u8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot270_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot270_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot270_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot270_u16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot270_u32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot270_u8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_f16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_f32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_u16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_u32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_u8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot90_f16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot90_f32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_f16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_f32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_u16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_u32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_u8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot90_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot90_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot90_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot90_u16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot90_u32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot90_u8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_f16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_f32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_u16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_u32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_u8.c: Likewise.
+
+2023-01-25  Andrea Corallo  <andrea.corallo@arm.com>
+
+	* gcc.target/arm/mve/intrinsics/vmulltq_int_m_s16.c: Use
+	check-function-bodies instead of scan-assembler checks.  Use
+	extern "C" for C++ testing.
+	* gcc.target/arm/mve/intrinsics/vmulltq_int_m_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulltq_int_m_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulltq_int_m_u16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulltq_int_m_u32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulltq_int_m_u8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulltq_int_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulltq_int_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulltq_int_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulltq_int_u16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulltq_int_u32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulltq_int_u8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulltq_int_x_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulltq_int_x_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulltq_int_x_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulltq_int_x_u16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulltq_int_x_u32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulltq_int_x_u8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulltq_poly_m_p16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulltq_poly_m_p8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulltq_poly_p16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulltq_poly_p8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulltq_poly_x_p16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulltq_poly_x_p8.c: Likewise.
+
+2023-01-25  Andrea Corallo  <andrea.corallo@arm.com>
+
+	* gcc.target/arm/mve/intrinsics/vmullbq_int_m_s16.c: Use
+	check-function-bodies instead of scan-assembler checks.  Use
+	extern "C" for C++ testing.
+	* gcc.target/arm/mve/intrinsics/vmullbq_int_m_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmullbq_int_m_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmullbq_int_m_u16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmullbq_int_m_u32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmullbq_int_m_u8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmullbq_int_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmullbq_int_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmullbq_int_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmullbq_int_u16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmullbq_int_u32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmullbq_int_u8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmullbq_int_x_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmullbq_int_x_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmullbq_int_x_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmullbq_int_x_u16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmullbq_int_x_u32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmullbq_int_x_u8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmullbq_poly_m_p16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmullbq_poly_m_p8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmullbq_poly_p16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmullbq_poly_p8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmullbq_poly_x_p16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmullbq_poly_x_p8.c: Likewise.
+
+2023-01-25  Andrea Corallo  <andrea.corallo@arm.com>
+
+	* gcc.target/arm/mve/intrinsics/vmulhq_m_s16.c: Use
+	check-function-bodies instead of scan-assembler checks.  Use
+	extern "C" for C++ testing.
+	* gcc.target/arm/mve/intrinsics/vmulhq_m_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulhq_m_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulhq_m_u16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulhq_m_u32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulhq_m_u8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulhq_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulhq_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulhq_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulhq_u16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulhq_u32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulhq_u8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulhq_x_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulhq_x_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulhq_x_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulhq_x_u16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulhq_x_u32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vmulhq_x_u8.c: Likewise.
+
+2023-01-25  Andrea Corallo  <andrea.corallo@arm.com>
+
+	* gcc.target/arm/mve/intrinsics/vnegq_f16.c: Use
+	check-function-bodies instead of scan-assembler checks.  Use
+	extern "C" for C++ testing.
+	* gcc.target/arm/mve/intrinsics/vnegq_f32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vnegq_m_f16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vnegq_m_f32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vnegq_m_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vnegq_m_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vnegq_m_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vnegq_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vnegq_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vnegq_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vnegq_x_f16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vnegq_x_f32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vnegq_x_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vnegq_x_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vnegq_x_s8.c: Likewise.
+	* gcc.target/arm/simd/mve-vneg.c: Update test.
+	* gcc.target/arm/simd/mve-vshr.c: Likewise
+
+2023-01-25  Andrea Corallo  <andrea.corallo@arm.com>
+
+	* gcc.target/arm/mve/intrinsics/vclzq_m_s16.c: Use
+	check-function-bodies instead of scan-assembler checks.  Use
+	extern "C" for C++ testing.
+	* gcc.target/arm/mve/intrinsics/vclzq_m_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vclzq_m_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vclzq_m_u16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vclzq_m_u32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vclzq_m_u8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vclzq_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vclzq_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vclzq_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vclzq_u16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vclzq_u32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vclzq_u8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vclzq_x_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vclzq_x_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vclzq_x_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vclzq_x_u16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vclzq_x_u32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vclzq_x_u8.c: Likewise.
+	* gcc.target/arm/simd/mve-vclz.c: Update test.
+
+2023-01-25  Andrea Corallo  <andrea.corallo@arm.com>
+
+	* gcc.target/arm/mve/intrinsics/vclsq_m_s16.c: Use
+	check-function-bodies instead of scan-assembler checks. Use extern
+	"C" for C++ testing.
+	* gcc.target/arm/mve/intrinsics/vclsq_m_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vclsq_m_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vclsq_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vclsq_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vclsq_s8.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vclsq_x_s16.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vclsq_x_s32.c: Likewise.
+	* gcc.target/arm/mve/intrinsics/vclsq_x_s8.c: Likewise.
+
+2023-01-25  Richard Sandiford  <richard.sandiford@arm.com>
+
+	* gcc.target/aarch64/sve/acle/general-c/sizeless-1.c: Avoid
+	"initializer element is not constant" error.
+	* gcc.target/aarch64/sve/acle/general-c/sizeless-2.c: Likewise.
+
+2023-01-25  Andre Vieira  <andre.simoesdiasvieira@arm.com>
+
+	* lib/target-supports.exp (check_effective_target_vect_long_long): Add
+	aarch64 to list of targets supporting long long vectorization.
+
+2023-01-25  Jakub Jelinek  <jakub@redhat.com>
+
+	PR tree-optimization/108498
+	* gcc.c-torture/execute/pr108498-1.c: New test.
+	* gcc.c-torture/execute/pr108498-2.c: New test.
+
+2023-01-25  Siddhesh Poyarekar  <siddhesh@gotplt.org>
+	    Jakub Jelinek  <jakub@redhat.com>
+
+	PR tree-optimization/108522
+	* gcc.dg/builtin-dynamic-object-size-0.c
+	(test_dynarray_struct_member): New test.
+	(main): Call it.
+
+2023-01-24  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/107329
+	PR testsuite/108533
+	* g++.dg/init/new51.C (size_t): New typedef.
+	(RexxClass::operator new, RexxClass::operator delete): Use size_t
+	instead of unsigned long.
+
+2023-01-24  Jason Merrill  <jason@redhat.com>
+
+	PR c++/108504
+	* g++.dg/ext/pragma1.C: New test.
+
+2023-01-24  Jason Merrill  <jason@redhat.com>
+
+	PR c++/108526
+	* g++.dg/cpp23/static-operator-call5.C: New test.
+
+2023-01-24  Vladimir N. Makarov  <vmakarov@redhat.com>
+
+	* gcc.target/pdp11/pdp11.exp: New.
+	* gcc.target/pdp11/pr108388.c: New.
+
+2023-01-24  Harald Anlauf  <anlauf@gmx.de>
+
+	PR fortran/108529
+	* gfortran.dg/pr108529.f90: New test.
+
+2023-01-24  Andre Vieira  <andre.simoesdiasvieira@arm.com>
+
+	* gcc.target/arm/mve/pr108177-1-run.c: New test.
+	* gcc.target/arm/mve/pr108177-1.c: New test.
+	* gcc.target/arm/mve/pr108177-10-run.c: New test.
+	* gcc.target/arm/mve/pr108177-10.c: New test.
+	* gcc.target/arm/mve/pr108177-11-run.c: New test.
+	* gcc.target/arm/mve/pr108177-11.c: New test.
+	* gcc.target/arm/mve/pr108177-12-run.c: New test.
+	* gcc.target/arm/mve/pr108177-12.c: New test.
+	* gcc.target/arm/mve/pr108177-13-run.c: New test.
+	* gcc.target/arm/mve/pr108177-13.c: New test.
+	* gcc.target/arm/mve/pr108177-14-run.c: New test.
+	* gcc.target/arm/mve/pr108177-14.c: New test.
+	* gcc.target/arm/mve/pr108177-2-run.c: New test.
+	* gcc.target/arm/mve/pr108177-2.c: New test.
+	* gcc.target/arm/mve/pr108177-3-run.c: New test.
+	* gcc.target/arm/mve/pr108177-3.c: New test.
+	* gcc.target/arm/mve/pr108177-4-run.c: New test.
+	* gcc.target/arm/mve/pr108177-4.c: New test.
+	* gcc.target/arm/mve/pr108177-5-run.c: New test.
+	* gcc.target/arm/mve/pr108177-5.c: New test.
+	* gcc.target/arm/mve/pr108177-6-run.c: New test.
+	* gcc.target/arm/mve/pr108177-6.c: New test.
+	* gcc.target/arm/mve/pr108177-7-run.c: New test.
+	* gcc.target/arm/mve/pr108177-7.c: New test.
+	* gcc.target/arm/mve/pr108177-8-run.c: New test.
+	* gcc.target/arm/mve/pr108177-8.c: New test.
+	* gcc.target/arm/mve/pr108177-9-run.c: New test.
+	* gcc.target/arm/mve/pr108177-9.c: New test.
+	* gcc.target/arm/mve/pr108177-main.x: New test include.
+	* gcc.target/arm/mve/pr108177.x: New test include.
+
+2023-01-24  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/108474
+	* g++.dg/cpp1z/decomp57.C: New test.
+	* g++.dg/cpp1z/decomp58.C: New test.
+
+2023-01-24  Rainer Orth  <ro@CeBiTec.Uni-Bielefeld.DE>
+
+	PR testsuite/107808
+	* gcc.dg/vect/vect-bitfield-write-2.c: Require vect_long_long.
+	* gcc.dg/vect/vect-bitfield-write-3.c: Likewise.
+
+2023-01-24  Rainer Orth  <ro@CeBiTec.Uni-Bielefeld.DE>
+
+	PR testsuite/104756
+	* gcc.dg/vect/vect-fmax-1.c: Require vect_float.
+	* gcc.dg/vect/vect-fmax-2.c: Likewise.
+	* gcc.dg/vect/vect-fmax-3.c: Likewise.
+	* gcc.dg/vect/vect-fmin-1.c: Likewise.
+	* gcc.dg/vect/vect-fmin-2.c: Likewise.
+	* gcc.dg/vect/vect-fmin-3.c: Likewise.
+
+2023-01-24  Lulu Cheng  <chenglulu@loongson.cn>
+	    Yang Yujie  <yangyujie@loongson.cn>
+
+	PR target/107731
+	* gcc.target/loongarch/tst-asm-const.c: Moved to...
+	* gcc.target/loongarch/pr107731.c: ...here.
+
+2023-01-24  Jason Merrill  <jason@redhat.com>
+
+	PR c++/107303
+	PR c++/107329
+	* g++.dg/ext/builtin-shufflevector-5.C: New test.
+	* g++.dg/init/new51.C: New test.
+
+2023-01-23  Jason Merrill  <jason@redhat.com>
+
+	PR c++/107267
+	* g++.dg/cpp0x/move2.C: New test.
+
+2023-01-23  Harald Anlauf  <anlauf@gmx.de>
+
+	PR fortran/108502
+	* gfortran.dg/pr108502.f90: New test.
+
+2023-01-23  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/107797
+	* g++.dg/warn/Wunused-value-1.C: New test.
+
+2023-01-23  Jason Merrill  <jason@redhat.com>
+
+	PR c++/108195
+	* g++.dg/cpp0x/initlist-vect2.C: New test.
+
+2023-01-23  Harald Anlauf  <anlauf@gmx.de>
+
+	PR fortran/108501
+	* gfortran.dg/pr108501.f90: New test.
+
+2023-01-23  Harald Anlauf  <anlauf@gmx.de>
+
+	PR fortran/108420
+	* gfortran.dg/pr108420.f90: New test.
+
+2023-01-23  Jason Merrill  <jason@redhat.com>
+
+	PR c++/108496
+	* g++.dg/template/explicit-instantiation5.C: New test.
+
+2023-01-23  Srinath Parvathaneni  <srinath.parvathaneni@arm.com>
+
+	* g++.target/arm/pac-1.C: New test.
+	* gcc.target/arm/pac-15.c: Likewise.
+
+2023-01-23  Srinath Parvathaneni  <srinath.parvathaneni@arm.com>
+
+	* gcc.target/arm/multilib.exp (multilib_config "rmprofile"): Update
+	tests.
+	* gcc.target/arm/pac-12.c: New test.
+	* gcc.target/arm/pac-13.c: Likewise.
+	* gcc.target/arm/pac-14.c: Likewise.
+
+2023-01-23  Srinath Parvathaneni  <srinath.parvathaneni@arm.com>
+
+	* gcc.target/arm/multilib.exp: Add tests for cortex-m85.
+
+2023-01-23  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/108482
+	* gcc.dg/torture/pr108482.c: New testcase.
+
+2023-01-23  Andrea Corallo  <andrea.corallo@arm.com>
+
+	* gcc.target/arm/bti-1.c: New testcase.
+	* gcc.target/arm/bti-2.c: Likewise.
+
+2023-01-23  Andrea Corallo  <andrea.corallo@arm.com>
+
+	* gcc.target/arm/pac.h : New file.
+	* gcc.target/arm/pac-1.c : New test case.
+	* gcc.target/arm/pac-2.c : Likewise.
+	* gcc.target/arm/pac-3.c : Likewise.
+	* gcc.target/arm/pac-4.c : Likewise.
+	* gcc.target/arm/pac-5.c : Likewise.
+	* gcc.target/arm/pac-6.c : Likewise.
+	* gcc.target/arm/pac-7.c : Likewise.
+	* gcc.target/arm/pac-8.c : Likewise.
+	* gcc.target/arm/pac-9.c : Likewise.
+	* gcc.target/arm/pac-10.c : Likewise.
+	* gcc.target/arm/pac-11.c : Likewise.
+
+2023-01-23  Andrea Corallo  <andrea.corallo@arm.com>
+
+	* gcc.target/arm/multilib.exp: Add pacbti related entries.
+
+2023-01-23  Andrea Corallo  <andrea.corallo@arm.com>
+	    Tejas Belagod   <tbelagod@arm.com>
+
+	* gcc.target/arm/acle/pacbti-m-predef-1.c: New test.
+	* gcc.target/arm/acle/pacbti-m-predef-3.c: Likewise.
+	* gcc.target/arm/acle/pacbti-m-predef-6.c: Likewise.
+	* gcc.target/arm/acle/pacbti-m-predef-7.c: Likewise.
+
+2023-01-23  Andrea Corallo  <andrea.corallo@arm.com>
+	    Tejas Belagod   <tbelagod@arm.com>
+
+	* lib/target-supports.exp
+	(check_effective_target_mbranch_protection_ok): New function.
+	* gcc.target/arm/acle/pacbti-m-predef-2.c: New test.
+	* gcc.target/arm/acle/pacbti-m-predef-4.c: Likewise.
+	* gcc.target/arm/acle/pacbti-m-predef-5.c: Likewise.
+	* gcc.target/arm/acle/pacbti-m-predef-8.c: Likewise.
+	* gcc.target/arm/acle/pacbti-m-predef-9.c: Likewise.
+	* gcc.target/arm/acle/pacbti-m-predef-10.c: Likewise.
+	* gcc.target/arm/acle/pacbti-m-predef-11.c: Likewise.
+	* gcc.target/arm/acle/pacbti-m-predef-12.c: Likewise.
+
+2023-01-23  Andrea Corallo  <andrea.corallo@arm.com>
+	    Tejas Belagod   <tbelagod@arm.com>
+
+	* lib/target-supports.exp:
+	(check_effective_target_arm_pacbti_hw): New.
+
+2023-01-23  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/108449
+	* gcc.dg/pr108449.c: New testcase.
+
+2023-01-23  Jason Merrill  <jason@redhat.com>
+
+	PR c++/53288
+	DR 1299
+	* g++.dg/init/lifetime4.C: New test.
+
+2023-01-22  Iain Sandoe  <iain@sandoe.co.uk>
+
+	* gm2/case/pass/case-pass.exp: Update for removal of concatenated
+	paths.
+	* gm2/complex/pass/complex-pass.exp: Likewise.
+	* gm2/coroutines/pim/run/pass/coroutines-pim-run-pass.exp: Likewise.
+	* gm2/iso/analysis/fail/iso-analysis-fail.exp: Likewise.
+	* gm2/iso/check/fail/iso-check-fail.exp: Likewise.
+	* gm2/iso/fail/iso-fail.exp: Likewise.
+	* gm2/iso/pass/iso-pass.exp: Likewise.
+	* gm2/isolib/run/pass/isolib-run-pass.exp: Likewise.
+	* gm2/pim/fail/pim-fail.exp: Likewise.
+	* gm2/pim/pass/pim-pass.exp: Likewise.
+	* gm2/pimlib/logitech/run/pass/pimlib-logitech-run-pass.exp: Likewise.
+	* gm2/pimlib/pass/pimlib-pass.exp: Likewise.
+	* gm2/pimlib/run/pass/pimlib-run-pass.exp: Likewise.
+	* gm2/projects/iso/run/pass/halma/projects-iso-run-pass-halma.exp: Likewise.
+	* gm2/projects/iso/run/pass/hello/projects-iso-run-pass-hello.exp: Likewise.
+	* gm2/projects/log/run/pass/hello/projects-log-run-pass-hello.exp: Likewise.
+	* gm2/projects/pim/run/pass/hello/projects-pim-run-pass-hello.exp: Likewise.
+	* gm2/recover/pass/recover-pass.exp: Likewise.
+	* gm2/switches/makeall/fail/switches-makeall-fail.exp: Likewise.
+	* gm2/switches/makeall/pass/switches-makeall-pass.exp: Likewise.
+	* gm2/switches/none/run/pass/gm2-none.exp: Likewise.
+	* gm2/switches/pim2/run/pass/switches-pim2-run-pass.exp: Likewise.
+	* gm2/ulmlib/pass/ulmlib-pass.exp: Likewise.
+	* gm2/ulmlib/std/pass/ulmlib-std-pass.exp: Likewise.
+	* gm2/ulmlib/sys/pass/ulmlib-sys-pass.exp: Likewise.
+	* lib/gm2.exp: Make the paths list a mandatory entry for each gm2_init_xxx
+	function. Remove the use of concatenated include and library paths.
+	Remove string processing where possible.
+
+2023-01-22  Dimitar Dimitrov  <dimitar@dinux.eu>
+
+	* gcc.target/pru/clz-hi-2.c: New test.
+	* gcc.target/pru/clz-hi.c: New test.
+
+2023-01-21  Jerry DeLisle  <jvdelisle@gcc.gnu.org>
+
+	PR fortran/102595
+	* gfortran.dg/pr88048.f90: Adjust for changed error message.
+	* gfortran.dg/parameter_data0.f90: New test.
+
+2023-01-20  Tejas Belagod  <tejas.belagod@arm.com>
+
+	* gcc.target/aarch64/acle/pmull64.c: New.
+	* gcc.target/aarch64/aes-fuse-1.c: Replace '+crypto' with corresponding
+	feature flag based on the intrinsic.
+	* gcc.target/aarch64/aes-fuse-2.c: Likewise.
+	* gcc.target/aarch64/aes_1.c: Likewise.
+	* gcc.target/aarch64/aes_2.c: Likewise.
+	* gcc.target/aarch64/aes_xor_combine.c: Likewise.
+	* gcc.target/aarch64/sha1_1.c: Likewise.
+	* gcc.target/aarch64/sha256_1.c: Likewise.
+	* gcc.target/aarch64/target_attr_crypto_ice_1.c: Likewise.
+
+2023-01-19  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/108437
+	* g++.dg/cpp23/subscript12.C: New test.
+	* g++.dg/cpp23/subscript13.C: New test.
+
+2023-01-19  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/53932
+	* g++.dg/init/pr53932.C: New test.
+
+2023-01-19  H.J. Lu  <hjl.tools@gmail.com>
+
+	* gcc.target/i386/pr108436.c: New test.
+
+2023-01-19  David Malcolm  <dmalcolm@redhat.com>
+
+	PR analyzer/108455
+	* gcc.dg/analyzer/deref-before-check-1.c: Add test coverage
+	involving dominance.
+	* gcc.dg/analyzer/deref-before-check-pr108455-1.c: New test.
+	* gcc.dg/analyzer/deref-before-check-pr108455-git-pack-revindex.c:
+	New test.
+
+2023-01-19  Harald Anlauf  <anlauf@gmx.de>
+
+	PR fortran/108434
+	* gfortran.dg/pr108434.f90: New test.
+
+2023-01-19  Iain Sandoe  <iain@sandoe.co.uk>
+
+	* gm2/complex/run/pass/complex-run-pass.exp: Remove gm2_link_lib.
+	* gm2/iso/run/pass/iso-run-pass.exp: Likewise.
+	* gm2/link/externalscaffold/pass/link-externalscaffold-pass.exp:
+	* gm2/pimlib/logitech/run/pass/pimlib-logitech-run-pass.exp: Likewise.
+	* gm2/pimlib/run/pass/pimlib-run-pass.exp: Likewise.
+	* gm2/projects/iso/run/pass/halma/projects-iso-run-pass-halma.exp:
+	Likewise.
+	* gm2/projects/iso/run/pass/hello/projects-iso-run-pass-hello.exp:
+	Likewise.
+	* gm2/projects/pim/run/pass/hello/projects-pim-run-pass-hello.exp:
+	Likewise.
+	* gm2/sets/run/pass/sets-run-pass.exp: Likewise.
+	* gm2/switches/none/run/pass/gm2-none.exp: Likewise.
+	* gm2/switches/pic/run/pass/switches-pic-run-pass.exp: Likewise.
+	* gm2/projects/pim/run/pass/random/projects-pim-run-pass-random.exp:
+	Likewise, and also ensure that the -g option is appended to avoid it
+	being taken as a path.
+	* lib/gm2.exp: Ensure for each gm2_init_xxxx function that the set of
+	libraries added matches the set of -I and -L options.
+
+2023-01-19  Christophe Lyon  <christophe.lyon@arm.com>
+
+	PR target/108411
+	* g++.target/aarch64/bitfield-abi-warning-align16-O2-extra.C: Add
+	-fno-stack-protector.
+	* g++.target/aarch64/bitfield-abi-warning-align16-O2.C: Likewise.
+	* g++.target/aarch64/bitfield-abi-warning-align32-O2-extra.C: Likewise.
+	* g++.target/aarch64/bitfield-abi-warning-align32-O2.C: Likewise.
+	* g++.target/aarch64/bitfield-abi-warning-align8-O2.C: Likewise.
+	* gcc.target/aarch64/bitfield-abi-warning-align16-O2-extra.c: Likewise.
+	* gcc.target/aarch64/bitfield-abi-warning-align16-O2.c: Likewise.
+	* gcc.target/aarch64/bitfield-abi-warning-align32-O2-extra.c: Likewise.
+	* gcc.target/aarch64/bitfield-abi-warning-align32-O2.c: Likewise.
+	* gcc.target/aarch64/bitfield-abi-warning-align8-O2.c: Likewise.
+
+2023-01-19  Jakub Jelinek  <jakub@redhat.com>
+
+	PR tree-optimization/108440
+	* c-c++-common/rotate-10.c: New test.
+	* c-c++-common/rotate-11.c: New test.
+
+2023-01-19  Alexandre Oliva  <oliva@adacore.com>
+
+	PR debug/106746
+	* gcc.target/i386/pr106746.c: New.
+
+2023-01-18  Marek Polacek  <polacek@redhat.com>
+
+	PR c/108424
+	* gcc.dg/c2x-nullptr-6.c: New test.
+
+2023-01-18  David Malcolm  <dmalcolm@redhat.com>
+
+	* gcc.dg/analyzer/SARD-tc117-basic-00001-min.c: New test, adapted
+	from https://samate.nist.gov/SARD/test-suites/81.
+	* gcc.dg/analyzer/SARD-tc1909-stack_overflow_loop.c: Likewise.
+	* gcc.dg/analyzer/SARD-tc249-basic-00034-min.c: Likewise.
+	* gcc.dg/analyzer/SARD-tc293-basic-00045-min.c: Likewise.
+	* gcc.dg/analyzer/SARD-tc841-basic-00182-min.c: Likewise.
+
+2023-01-18  Richard Biener  <rguenther@suse.de>
+
+	PR lto/108445
+	* gcc.dg/lto/pr108445_0.c: New testcase.
+	* gcc.dg/lto/pr108445_1.c: Likewise.
+
+2023-01-18  Murray Steele  <murray.steele@arm.com>
+
+	* gcc.target/arm/mve/general/preserve_user_namespace_1.c: New test.
+
+2023-01-18  Kewen Lin  <linkw@linux.ibm.com>
+	    Andrew Pinski  <apinski@marvell.com>
+
+	PR target/108396
+	* gcc.target/powerpc/pr108396.c: New test.
+
+2023-01-18  Kewen Lin  <linkw@linux.ibm.com>
+
+	PR target/108348
+	* gcc.target/powerpc/pr108348-1.c: New test.
+	* gcc.target/powerpc/pr108348-2.c: New test.
+
+2023-01-17  Harald Anlauf  <anlauf@gmx.de>
+
+	PR fortran/108421
+	* gfortran.dg/pr108421.f90: New test.
+
+2023-01-17  Jakub Jelinek  <jakub@redhat.com>
+
+	PR tree-optimization/106523
+	* c-c++-common/rotate-2.c (f5, f6, f7, f8, f13, f14, f15, f16,
+	f37, f38, f39, f40, f45, f46, f47, f48): Add assertions using
+	__builtin_unreachable about shift count.
+	* c-c++-common/rotate-2b.c: New test.
+	* c-c++-common/rotate-4.c (f5, f6, f7, f8, f13, f14, f15, f16,
+	f37, f38, f39, f40, f45, f46, f47, f48): Add assertions using
+	__builtin_unreachable about shift count.
+	* c-c++-common/rotate-4b.c: New test.
+	* gcc.c-torture/execute/pr106523.c: New test.
+
+2023-01-16  Andrew Pinski  <apinski@marvell.com>
+
+	* lib/target-supports.exp (add_options_for_tls): Remove
+	reference to Solaris 9 in comments.
+
+2023-01-16  H.J. Lu  <hjl.tools@gmail.com>
+
+	PR target/105980
+	* g++.target/i386/pr105980.C: New test.
+
+2023-01-16  Jan Hubicka  <hubicka@ucw.cz>
+
+	* g++.dg/tree-ssa/pr106077.C: New test.
+
+2023-01-16  Stam Markianos-Wright  <stam.markianos-wright@arm.com>
+
+	PR target/96795
+	PR target/107515
+	* gcc.target/arm/mve/intrinsics/mve_intrinsic_type_overloads-fp.c: New test.
+	* gcc.target/arm/mve/intrinsics/mve_intrinsic_type_overloads-int.c: New test.
+
+2023-01-16  Andrew Carlotti  <andrew.carlotti@arm.com>
+
+	* g++.dg/tree-ssa/pr86544.C: Add .POPCOUNT to tree scan regex.
+	* gcc.dg/tree-ssa/popcount.c: Likewise.
+	* gcc.dg/tree-ssa/popcount2.c: Likewise.
+	* gcc.dg/tree-ssa/popcount3.c: Likewise.
+	* gcc.target/aarch64/popcount4.c: Likewise.
+	* gcc.target/i386/pr95771.c: Likewise, and...
+	* gcc.target/i386/pr95771-2.c: ...split int128 test from above,
+	since this would emit just a single IFN if a TI optab is added.
+
+2023-01-16  Andrew Carlotti  <andrew.carlotti@arm.com>
+
+	* gcc.dg/tree-ssa/cltz-max.c: New test.
+	* gcc.dg/tree-ssa/clz-char.c: New test.
+	* gcc.dg/tree-ssa/clz-int.c: New test.
+	* gcc.dg/tree-ssa/clz-long-long.c: New test.
+	* gcc.dg/tree-ssa/clz-long.c: New test.
+	* gcc.dg/tree-ssa/ctz-char.c: New test.
+	* gcc.dg/tree-ssa/ctz-int.c: New test.
+	* gcc.dg/tree-ssa/ctz-long-long.c: New test.
+	* gcc.dg/tree-ssa/ctz-long.c: New test.
+
+2023-01-16  Andrew Carlotti  <andrew.carlotti@arm.com>
+
+	* lib/target-supports.exp (check_effective_target_clz)
+	(check_effective_target_clzl, check_effective_target_clzll)
+	(check_effective_target_ctz, check_effective_target_clzl)
+	(check_effective_target_ctzll): New.
+	* gcc.dg/tree-ssa/cltz-complement-max.c: New test.
+	* gcc.dg/tree-ssa/clz-complement-char.c: New test.
+	* gcc.dg/tree-ssa/clz-complement-int.c: New test.
+	* gcc.dg/tree-ssa/clz-complement-long-long.c: New test.
+	* gcc.dg/tree-ssa/clz-complement-long.c: New test.
+	* gcc.dg/tree-ssa/ctz-complement-char.c: New test.
+	* gcc.dg/tree-ssa/ctz-complement-int.c: New test.
+	* gcc.dg/tree-ssa/ctz-complement-long-long.c: New test.
+	* gcc.dg/tree-ssa/ctz-complement-long.c: New test.
+
+2023-01-16  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/105593
+	* g++.target/i386/pr105593.C: New test.
+
+2023-01-16  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/105593
+	* c-c++-common/Winit-self3.c: New test.
+	* c-c++-common/Winit-self4.c: New test.
+	* c-c++-common/Winit-self5.c: New test.
+
+2023-01-16  Kewen Lin  <linkw@linux.ibm.com>
+
+	PR target/108272
+	* gcc.target/powerpc/pr108272-1.c: New test.
+	* gcc.target/powerpc/pr108272-2.c: New test.
+	* gcc.target/powerpc/pr108272-3.c: New test.
+	* gcc.target/powerpc/pr108272-4.c: New test.
+
 2023-01-14  Prathamesh Kulkarni  <prathamesh.kulkarni@linaro.org>
 
 	* gcc.target/aarch64/sve/acle/general/pr96463-2.c: Adjust.
diff --git a/gcc/testsuite/ChangeLog-2022 b/gcc/testsuite/ChangeLog-2022
index d9fafcc..9782784 100644
--- a/gcc/testsuite/ChangeLog-2022
+++ b/gcc/testsuite/ChangeLog-2022
@@ -11,7 +11,7 @@
 
 2022-12-30  Steve Kargl  <kargl@gcc.gnu.org>
 
-	PR fortran/102595
+	PR fortran/102331
 	* gfortran.dg/class_result_4.f90: Update error message check.
 	* gfortran.dg/pr85779_3.f90: Update error message check.
 
diff --git a/gcc/testsuite/c-c++-common/asan/pointer-subtract-5.c b/gcc/testsuite/c-c++-common/asan/pointer-subtract-5.c
new file mode 100644
index 0000000..867eda0
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/asan/pointer-subtract-5.c
@@ -0,0 +1,15 @@
+/* PR middle-end/108543 */
+/* { dg-do compile  } */
+/* { dg-options "-fsanitize=address -fno-sanitize=kernel-address -fsanitize=pointer-subtract" } */
+
+struct S {
+  long _M_p;
+};
+
+typedef struct S S;
+
+__PTRDIFF_TYPE__
+f (S __x, S __y)
+{
+  return &__x._M_p - &__y._M_p;
+}
diff --git a/gcc/testsuite/c-c++-common/asan/pointer-subtract-6.c b/gcc/testsuite/c-c++-common/asan/pointer-subtract-6.c
new file mode 100644
index 0000000..785b90b
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/asan/pointer-subtract-6.c
@@ -0,0 +1,15 @@
+/* PR middle-end/108543 */
+/* { dg-do compile  } */
+/* { dg-options "-fsanitize=kernel-address -fno-sanitize=address -fsanitize=pointer-subtract" } */
+
+struct S {
+  long _M_p;
+};
+
+typedef struct S S;
+
+__PTRDIFF_TYPE__
+f (S __x, S __y)
+{
+  return &__x._M_p - &__y._M_p;
+}
diff --git a/gcc/testsuite/c-c++-common/asan/pointer-subtract-7.c b/gcc/testsuite/c-c++-common/asan/pointer-subtract-7.c
new file mode 100644
index 0000000..11b6340
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/asan/pointer-subtract-7.c
@@ -0,0 +1,15 @@
+/* PR middle-end/108543 */
+/* { dg-do compile  } */
+/* { dg-options "-fno-sanitize=kernel-address -fsanitize=address -fsanitize=pointer-subtract" } */
+
+struct S {
+  long _M_p;
+};
+
+typedef struct S S;
+
+__PTRDIFF_TYPE__
+f (S __x, S __y)
+{
+  return &__x._M_p - &__y._M_p;
+}
diff --git a/gcc/testsuite/c-c++-common/asan/pointer-subtract-8.c b/gcc/testsuite/c-c++-common/asan/pointer-subtract-8.c
new file mode 100644
index 0000000..ac2b9c3
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/asan/pointer-subtract-8.c
@@ -0,0 +1,15 @@
+/* PR middle-end/108543 */
+/* { dg-do compile  } */
+/* { dg-options "-fno-sanitize=address -fsanitize=kernel-address -fsanitize=pointer-subtract" } */
+
+struct S {
+  long _M_p;
+};
+
+typedef struct S S;
+
+__PTRDIFF_TYPE__
+f (S __x, S __y)
+{
+  return &__x._M_p - &__y._M_p;
+}
diff --git a/gcc/testsuite/c-c++-common/hwasan/arguments-3.c b/gcc/testsuite/c-c++-common/hwasan/arguments-3.c
index 2bf8917..6dbec92 100644
--- a/gcc/testsuite/c-c++-common/hwasan/arguments-3.c
+++ b/gcc/testsuite/c-c++-common/hwasan/arguments-3.c
@@ -1,5 +1,5 @@
 /* { dg-do compile } */
 /* { dg-additional-options "-fsanitize=thread,address" } */
-/* { dg-error ".*'-fsanitize=thread' is incompatible with '-fsanitize=address'.*" "" { target *-*-* } 0 } */
-/* { dg-error ".*'-fsanitize=thread' is incompatible with '-fsanitize=hwaddress'.*" "" { target *-*-* } 0 } */
-/* { dg-error ".*'-fsanitize=hwaddress' is incompatible with '-fsanitize=address'.*" "" { target *-*-* } 0 } */
+/* { dg-error "'-fsanitize=thread' is incompatible with '-fsanitize=address'" "" { target *-*-* } 0 } */
+/* { dg-error "'-fsanitize=thread' is incompatible with '-fsanitize=hwaddress'" "" { target *-*-* } 0 } */
+/* { dg-error "'-fsanitize=hwaddress' is incompatible with '-fsanitize=address'" "" { target *-*-* } 0 } */
diff --git a/gcc/testsuite/c-c++-common/rotate-10.c b/gcc/testsuite/c-c++-common/rotate-10.c
new file mode 100644
index 0000000..683d2cb
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/rotate-10.c
@@ -0,0 +1,53 @@
+/* PR tree-optimization/108440 */
+/* { dg-do compile { target { { ilp32 || lp64 } || llp64 } } } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+/* { dg-final { scan-tree-dump-times " r<< " 5 "optimized" } } */
+/* { dg-final { scan-tree-dump-times " \\\& 7;" 4 "optimized" } } */
+
+unsigned char
+foo (unsigned char x, unsigned int y)
+{
+  if (y > __CHAR_BIT__)
+    __builtin_unreachable ();
+  return (x << y) | (x >> ((-y) & (__CHAR_BIT__ - 1)));
+}
+
+unsigned char
+bar (unsigned char x, unsigned int y)
+{
+  if (y >= __CHAR_BIT__)
+    __builtin_unreachable ();
+  return (x << y) | (x >> ((-y) & (__CHAR_BIT__ - 1)));
+}
+
+unsigned char
+baz (unsigned char x, unsigned int y)
+{
+  if (y > __CHAR_BIT__ && y != 2 * __CHAR_BIT__)
+    __builtin_unreachable ();
+  return (x << y) | (x >> ((-y) & (__CHAR_BIT__ - 1)));
+}
+
+unsigned char
+qux (unsigned char x, unsigned int y)
+{
+  if (y > __CHAR_BIT__ && y != 2 * __CHAR_BIT__ && y != __CHAR_BIT__ + 2)
+    __builtin_unreachable ();
+  return (x << y) | (x >> ((-y) & (__CHAR_BIT__ - 1)));
+}
+
+unsigned char
+quux (unsigned char x, unsigned int y)
+{
+  if (y > __CHAR_BIT__)
+    __builtin_unreachable ();
+  return (x << y) | (x >> (__CHAR_BIT__ - y));
+}
+
+unsigned char
+corge (unsigned char x, unsigned int y)
+{
+  if (y >= __CHAR_BIT__)
+    __builtin_unreachable ();
+  return (x << y) | (x >> (__CHAR_BIT__ - y));
+}
diff --git a/gcc/testsuite/c-c++-common/rotate-11.c b/gcc/testsuite/c-c++-common/rotate-11.c
new file mode 100644
index 0000000..e57db19
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/rotate-11.c
@@ -0,0 +1,53 @@
+/* PR tree-optimization/108440 */
+/* { dg-do compile { target { { ilp32 || lp64 } || llp64 } } } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+/* { dg-final { scan-tree-dump-times " r<< " 5 "optimized" } } */
+/* { dg-final { scan-tree-dump-times " \\\& 7;" 4 "optimized" } } */
+
+unsigned char
+foo (unsigned char x, unsigned int y)
+{
+  if (y > __CHAR_BIT__)
+    return 42;
+  return (x << y) | (x >> ((-y) & (__CHAR_BIT__ - 1)));
+}
+
+unsigned char
+bar (unsigned char x, unsigned int y)
+{
+  if (y >= __CHAR_BIT__)
+    return 42;
+  return (x << y) | (x >> ((-y) & (__CHAR_BIT__ - 1)));
+}
+
+unsigned char
+baz (unsigned char x, unsigned int y)
+{
+  if (y > __CHAR_BIT__ && y != 2 * __CHAR_BIT__)
+    return 42;
+  return (x << y) | (x >> ((-y) & (__CHAR_BIT__ - 1)));
+}
+
+unsigned char
+qux (unsigned char x, unsigned int y)
+{
+  if (y > __CHAR_BIT__ && y != 2 * __CHAR_BIT__ && y != __CHAR_BIT__ + 2)
+    return 42;
+  return (x << y) | (x >> ((-y) & (__CHAR_BIT__ - 1)));
+}
+
+unsigned char
+quux (unsigned char x, unsigned int y)
+{
+  if (y > __CHAR_BIT__)
+    return 42;
+  return (x << y) | (x >> (__CHAR_BIT__ - y));
+}
+
+unsigned char
+corge (unsigned char x, unsigned int y)
+{
+  if (y >= __CHAR_BIT__)
+    return 42;
+  return (x << y) | (x >> (__CHAR_BIT__ - y));
+}
diff --git a/gcc/testsuite/c-c++-common/rotate-2.c b/gcc/testsuite/c-c++-common/rotate-2.c
index c8359cd..544a7ca 100644
--- a/gcc/testsuite/c-c++-common/rotate-2.c
+++ b/gcc/testsuite/c-c++-common/rotate-2.c
@@ -32,24 +32,32 @@ f4 (unsigned int x, int y __attribute__((unused)))
 unsigned short int
 f5 (unsigned short int x, unsigned int y)
 {
+  if (y >= __CHAR_BIT__ * __SIZEOF_SHORT__)
+    __builtin_unreachable ();
   return (x << y) | (x >> ((-y) & (__CHAR_BIT__ * __SIZEOF_SHORT__ - 1)));
 }
 
 unsigned short int
 f6 (unsigned short int x, unsigned long int y)
 {
+  if (y >= __CHAR_BIT__ * __SIZEOF_SHORT__)
+    __builtin_unreachable ();
   return (x << y) | (x >> ((-y) & (__CHAR_BIT__ * __SIZEOF_SHORT__ - 1)));
 }
 
 unsigned char
 f7 (unsigned char x, unsigned int y)
 {
+  if (y >= __CHAR_BIT__)
+    __builtin_unreachable ();
   return (x << y) | (x >> ((-y) & (__CHAR_BIT__ - 1)));
 }
 
 unsigned char
 f8 (unsigned char x, unsigned long int y)
 {
+  if (y >= __CHAR_BIT__)
+    __builtin_unreachable ();
   return (x << y) | (x >> ((-y) & (__CHAR_BIT__ - 1)));
 }
 
@@ -80,24 +88,32 @@ f12 (unsigned int x, int y __attribute__((unused)))
 unsigned short int
 f13 (unsigned short int x, unsigned int y)
 {
+  if (y >= __CHAR_BIT__ * __SIZEOF_SHORT__)
+    __builtin_unreachable ();
   return (x << y) | (x >> ((-y) & (__CHAR_BIT__ * sizeof (unsigned short) - 1)));
 }
 
 unsigned short int
 f14 (unsigned short int x, unsigned long int y)
 {
+  if (y >= __CHAR_BIT__ * __SIZEOF_SHORT__)
+    __builtin_unreachable ();
   return (x << y) | (x >> ((-y) & (__CHAR_BIT__ * sizeof (unsigned short) - 1)));
 }
 
 unsigned char
 f15 (unsigned char x, unsigned int y)
 {
+  if (y >= __CHAR_BIT__)
+    __builtin_unreachable ();
   return (x << y) | (x >> ((-y) & (__CHAR_BIT__ * sizeof (unsigned char) - 1)));
 }
 
 unsigned char
 f16 (unsigned char x, unsigned long int y)
 {
+  if (y >= __CHAR_BIT__)
+    __builtin_unreachable ();
   return (x << y) | (x >> ((-y) & (__CHAR_BIT__ * sizeof (unsigned char) - 1)));
 }
 
@@ -224,24 +240,32 @@ f36 (unsigned int x, int y __attribute__((unused)))
 unsigned short int
 f37 (unsigned short int x, unsigned int y)
 {
+  if (y >= __CHAR_BIT__ * __SIZEOF_SHORT__)
+    __builtin_unreachable ();
   return (x >> y) | (x << ((-y) & (__CHAR_BIT__ * __SIZEOF_SHORT__ - 1)));
 }
 
 unsigned short int
 f38 (unsigned short int x, unsigned long int y)
 {
+  if (y >= __CHAR_BIT__ * __SIZEOF_SHORT__)
+    __builtin_unreachable ();
   return (x >> y) | (x << ((-y) & (__CHAR_BIT__ * __SIZEOF_SHORT__ - 1)));
 }
 
 unsigned char
 f39 (unsigned char x, unsigned int y)
 {
+  if (y >= __CHAR_BIT__)
+    __builtin_unreachable ();
   return (x >> y) | (x << ((-y) & (__CHAR_BIT__ - 1)));
 }
 
 unsigned char
 f40 (unsigned char x, unsigned long int y)
 {
+  if (y >= __CHAR_BIT__)
+    __builtin_unreachable ();
   return (x >> y) | (x << ((-y) & (__CHAR_BIT__ - 1)));
 }
 
@@ -272,24 +296,32 @@ f44 (unsigned int x, int y __attribute__((unused)))
 unsigned short int
 f45 (unsigned short int x, unsigned int y)
 {
+  if (y >= __CHAR_BIT__ * __SIZEOF_SHORT__)
+    __builtin_unreachable ();
   return (x >> y) | (x << ((-y) & (__CHAR_BIT__ * sizeof (unsigned short) - 1)));
 }
 
 unsigned short int
 f46 (unsigned short int x, unsigned long int y)
 {
+  if (y >= __CHAR_BIT__ * __SIZEOF_SHORT__)
+    __builtin_unreachable ();
   return (x >> y) | (x << ((-y) & (__CHAR_BIT__ * sizeof (unsigned short) - 1)));
 }
 
 unsigned char
 f47 (unsigned char x, unsigned int y)
 {
+  if (y >= __CHAR_BIT__)
+    __builtin_unreachable ();
   return (x >> y) | (x << ((-y) & (__CHAR_BIT__ * sizeof (unsigned char) - 1)));
 }
 
 unsigned char
 f48 (unsigned char x, unsigned long int y)
 {
+  if (y >= __CHAR_BIT__)
+    __builtin_unreachable ();
   return (x >> y) | (x << ((-y) & (__CHAR_BIT__ * sizeof (unsigned char) - 1)));
 }
 
diff --git a/gcc/testsuite/c-c++-common/rotate-2b.c b/gcc/testsuite/c-c++-common/rotate-2b.c
new file mode 100644
index 0000000..2a6bf90
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/rotate-2b.c
@@ -0,0 +1,100 @@
+/* Check rotate pattern detection.  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fno-ipa-icf -fdump-tree-optimized" } */
+/* { dg-final { scan-tree-dump-not "r\[<>]\[<>]" "optimized" } } */
+
+unsigned short int
+f5 (unsigned short int x, unsigned int y)
+{
+  return (x << y) | (x >> ((-y) & (__CHAR_BIT__ * __SIZEOF_SHORT__ - 1)));
+}
+
+unsigned short int
+f6 (unsigned short int x, unsigned long int y)
+{
+  return (x << y) | (x >> ((-y) & (__CHAR_BIT__ * __SIZEOF_SHORT__ - 1)));
+}
+
+unsigned char
+f7 (unsigned char x, unsigned int y)
+{
+  return (x << y) | (x >> ((-y) & (__CHAR_BIT__ - 1)));
+}
+
+unsigned char
+f8 (unsigned char x, unsigned long int y)
+{
+  return (x << y) | (x >> ((-y) & (__CHAR_BIT__ - 1)));
+}
+
+unsigned short int
+f13 (unsigned short int x, unsigned int y)
+{
+  return (x << y) | (x >> ((-y) & (__CHAR_BIT__ * sizeof (unsigned short) - 1)));
+}
+
+unsigned short int
+f14 (unsigned short int x, unsigned long int y)
+{
+  return (x << y) | (x >> ((-y) & (__CHAR_BIT__ * sizeof (unsigned short) - 1)));
+}
+
+unsigned char
+f15 (unsigned char x, unsigned int y)
+{
+  return (x << y) | (x >> ((-y) & (__CHAR_BIT__ * sizeof (unsigned char) - 1)));
+}
+
+unsigned char
+f16 (unsigned char x, unsigned long int y)
+{
+  return (x << y) | (x >> ((-y) & (__CHAR_BIT__ * sizeof (unsigned char) - 1)));
+}
+
+unsigned short int
+f37 (unsigned short int x, unsigned int y)
+{
+  return (x >> y) | (x << ((-y) & (__CHAR_BIT__ * __SIZEOF_SHORT__ - 1)));
+}
+
+unsigned short int
+f38 (unsigned short int x, unsigned long int y)
+{
+  return (x >> y) | (x << ((-y) & (__CHAR_BIT__ * __SIZEOF_SHORT__ - 1)));
+}
+
+unsigned char
+f39 (unsigned char x, unsigned int y)
+{
+  return (x >> y) | (x << ((-y) & (__CHAR_BIT__ - 1)));
+}
+
+unsigned char
+f40 (unsigned char x, unsigned long int y)
+{
+  return (x >> y) | (x << ((-y) & (__CHAR_BIT__ - 1)));
+}
+
+unsigned short int
+f45 (unsigned short int x, unsigned int y)
+{
+  return (x >> y) | (x << ((-y) & (__CHAR_BIT__ * sizeof (unsigned short) - 1)));
+}
+
+unsigned short int
+f46 (unsigned short int x, unsigned long int y)
+{
+  return (x >> y) | (x << ((-y) & (__CHAR_BIT__ * sizeof (unsigned short) - 1)));
+}
+
+unsigned char
+f47 (unsigned char x, unsigned int y)
+{
+  return (x >> y) | (x << ((-y) & (__CHAR_BIT__ * sizeof (unsigned char) - 1)));
+}
+
+unsigned char
+f48 (unsigned char x, unsigned long int y)
+{
+  return (x >> y) | (x << ((-y) & (__CHAR_BIT__ * sizeof (unsigned char) - 1)));
+}
diff --git a/gcc/testsuite/c-c++-common/rotate-4.c b/gcc/testsuite/c-c++-common/rotate-4.c
index 44fd1d0..f852362 100644
--- a/gcc/testsuite/c-c++-common/rotate-4.c
+++ b/gcc/testsuite/c-c++-common/rotate-4.c
@@ -32,24 +32,32 @@ f4 (unsigned int x, int y __attribute__((unused)))
 unsigned short int
 f5 (unsigned short int x, int y)
 {
+  if (y >= __CHAR_BIT__ * __SIZEOF_SHORT__)
+    __builtin_unreachable ();
   return (x << y) | (x >> ((-y) & (__CHAR_BIT__ * __SIZEOF_SHORT__ - 1)));
 }
 
 unsigned short int
 f6 (unsigned short int x, long int y)
 {
+  if (y >= 0UL + __CHAR_BIT__ * __SIZEOF_SHORT__)
+    __builtin_unreachable ();
   return (x << y) | (x >> ((-y) & (__CHAR_BIT__ * __SIZEOF_SHORT__ - 1)));
 }
 
 unsigned char
 f7 (unsigned char x, int y)
 {
+  if (y >= __CHAR_BIT__)
+    __builtin_unreachable ();
   return (x << y) | (x >> ((-y) & (__CHAR_BIT__ - 1)));
 }
 
 unsigned char
 f8 (unsigned char x, long int y)
 {
+  if (y >= 0UL + __CHAR_BIT__)
+    __builtin_unreachable ();
   return (x << y) | (x >> ((-y) & (__CHAR_BIT__ - 1)));
 }
 
@@ -80,24 +88,32 @@ f12 (unsigned int x, int y __attribute__((unused)))
 unsigned short int
 f13 (unsigned short int x, int y)
 {
+  if (y >= __CHAR_BIT__ * __SIZEOF_SHORT__)
+    __builtin_unreachable ();
   return (x << y) | (x >> ((-y) & (__CHAR_BIT__ * sizeof (unsigned short) - 1)));
 }
 
 unsigned short int
 f14 (unsigned short int x, long int y)
 {
+  if (y >= 0UL + __CHAR_BIT__ * __SIZEOF_SHORT__)
+    __builtin_unreachable ();
   return (x << y) | (x >> ((-y) & (__CHAR_BIT__ * sizeof (unsigned short) - 1)));
 }
 
 unsigned char
 f15 (unsigned char x, int y)
 {
+  if (y >= __CHAR_BIT__)
+    __builtin_unreachable ();
   return (x << y) | (x >> ((-y) & (__CHAR_BIT__ * sizeof (unsigned char) - 1)));
 }
 
 unsigned char
 f16 (unsigned char x, long int y)
 {
+  if (y >= 0UL + __CHAR_BIT__)
+    __builtin_unreachable ();
   return (x << y) | (x >> ((-y) & (__CHAR_BIT__ * sizeof (unsigned char) - 1)));
 }
 
@@ -224,24 +240,32 @@ f36 (unsigned int x, int y __attribute__((unused)))
 unsigned short int
 f37 (unsigned short int x, int y)
 {
+  if (y >= __CHAR_BIT__ * __SIZEOF_SHORT__)
+    __builtin_unreachable ();
   return (x >> y) | (x << ((-y) & (__CHAR_BIT__ * __SIZEOF_SHORT__ - 1)));
 }
 
 unsigned short int
 f38 (unsigned short int x, long int y)
 {
+  if (y >= 0UL + __CHAR_BIT__ * __SIZEOF_SHORT__)
+    __builtin_unreachable ();
   return (x >> y) | (x << ((-y) & (__CHAR_BIT__ * __SIZEOF_SHORT__ - 1)));
 }
 
 unsigned char
 f39 (unsigned char x, int y)
 {
+  if (y >= __CHAR_BIT__)
+    __builtin_unreachable ();
   return (x >> y) | (x << ((-y) & (__CHAR_BIT__ - 1)));
 }
 
 unsigned char
 f40 (unsigned char x, long int y)
 {
+  if (y >= 0UL + __CHAR_BIT__)
+    __builtin_unreachable ();
   return (x >> y) | (x << ((-y) & (__CHAR_BIT__ - 1)));
 }
 
@@ -272,24 +296,32 @@ f44 (unsigned int x, int y __attribute__((unused)))
 unsigned short int
 f45 (unsigned short int x, int y)
 {
+  if (y >= __CHAR_BIT__ * __SIZEOF_SHORT__)
+    __builtin_unreachable ();
   return (x >> y) | (x << ((-y) & (__CHAR_BIT__ * sizeof (unsigned short) - 1)));
 }
 
 unsigned short int
 f46 (unsigned short int x, long int y)
 {
+  if (y >= 0UL + __CHAR_BIT__ * __SIZEOF_SHORT__)
+    __builtin_unreachable ();
   return (x >> y) | (x << ((-y) & (__CHAR_BIT__ * sizeof (unsigned short) - 1)));
 }
 
 unsigned char
 f47 (unsigned char x, int y)
 {
+  if (y >= __CHAR_BIT__)
+    __builtin_unreachable ();
   return (x >> y) | (x << ((-y) & (__CHAR_BIT__ * sizeof (unsigned char) - 1)));
 }
 
 unsigned char
 f48 (unsigned char x, long int y)
 {
+  if (y >= 0UL + __CHAR_BIT__)
+    __builtin_unreachable ();
   return (x >> y) | (x << ((-y) & (__CHAR_BIT__ * sizeof (unsigned char) - 1)));
 }
 
diff --git a/gcc/testsuite/c-c++-common/rotate-4b.c b/gcc/testsuite/c-c++-common/rotate-4b.c
new file mode 100644
index 0000000..a382475
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/rotate-4b.c
@@ -0,0 +1,100 @@
+/* Check rotate pattern detection.  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fno-ipa-icf -fdump-tree-optimized" } */
+/* { dg-final { scan-tree-dump-not "r\[<>]\[<>]" "optimized" } } */
+
+unsigned short int
+f5 (unsigned short int x, int y)
+{
+  return (x << y) | (x >> ((-y) & (__CHAR_BIT__ * __SIZEOF_SHORT__ - 1)));
+}
+
+unsigned short int
+f6 (unsigned short int x, long int y)
+{
+  return (x << y) | (x >> ((-y) & (__CHAR_BIT__ * __SIZEOF_SHORT__ - 1)));
+}
+
+unsigned char
+f7 (unsigned char x, int y)
+{
+  return (x << y) | (x >> ((-y) & (__CHAR_BIT__ - 1)));
+}
+
+unsigned char
+f8 (unsigned char x, long int y)
+{
+  return (x << y) | (x >> ((-y) & (__CHAR_BIT__ - 1)));
+}
+
+unsigned short int
+f13 (unsigned short int x, int y)
+{
+  return (x << y) | (x >> ((-y) & (__CHAR_BIT__ * sizeof (unsigned short) - 1)));
+}
+
+unsigned short int
+f14 (unsigned short int x, long int y)
+{
+  return (x << y) | (x >> ((-y) & (__CHAR_BIT__ * sizeof (unsigned short) - 1)));
+}
+
+unsigned char
+f15 (unsigned char x, int y)
+{
+  return (x << y) | (x >> ((-y) & (__CHAR_BIT__ * sizeof (unsigned char) - 1)));
+}
+
+unsigned char
+f16 (unsigned char x, long int y)
+{
+  return (x << y) | (x >> ((-y) & (__CHAR_BIT__ * sizeof (unsigned char) - 1)));
+}
+
+unsigned short int
+f37 (unsigned short int x, int y)
+{
+  return (x >> y) | (x << ((-y) & (__CHAR_BIT__ * __SIZEOF_SHORT__ - 1)));
+}
+
+unsigned short int
+f38 (unsigned short int x, long int y)
+{
+  return (x >> y) | (x << ((-y) & (__CHAR_BIT__ * __SIZEOF_SHORT__ - 1)));
+}
+
+unsigned char
+f39 (unsigned char x, int y)
+{
+  return (x >> y) | (x << ((-y) & (__CHAR_BIT__ - 1)));
+}
+
+unsigned char
+f40 (unsigned char x, long int y)
+{
+  return (x >> y) | (x << ((-y) & (__CHAR_BIT__ - 1)));
+}
+
+unsigned short int
+f45 (unsigned short int x, int y)
+{
+  return (x >> y) | (x << ((-y) & (__CHAR_BIT__ * sizeof (unsigned short) - 1)));
+}
+
+unsigned short int
+f46 (unsigned short int x, long int y)
+{
+  return (x >> y) | (x << ((-y) & (__CHAR_BIT__ * sizeof (unsigned short) - 1)));
+}
+
+unsigned char
+f47 (unsigned char x, int y)
+{
+  return (x >> y) | (x << ((-y) & (__CHAR_BIT__ * sizeof (unsigned char) - 1)));
+}
+
+unsigned char
+f48 (unsigned char x, long int y)
+{
+  return (x >> y) | (x << ((-y) & (__CHAR_BIT__ * sizeof (unsigned char) - 1)));
+}
diff --git a/gcc/testsuite/g++.dg/cet-notrack-1.C b/gcc/testsuite/g++.dg/cet-notrack-1.C
index ee98fd4..a19eed0 100644
--- a/gcc/testsuite/g++.dg/cet-notrack-1.C
+++ b/gcc/testsuite/g++.dg/cet-notrack-1.C
@@ -18,8 +18,8 @@ B b;
 A& a = b;
 int (A::*amem) () __attribute__((nocf_check)) = &A::foo; // take address
 if ((a.*amem)() == 73) // use the address
-  printf("pass\n");
+  puts("pass\n");
 else
-  printf("fail\n");
+  puts("fail\n");
 return 0;
 }
diff --git a/gcc/testsuite/g++.dg/cpp0x/initlist-vect2.C b/gcc/testsuite/g++.dg/cpp0x/initlist-vect2.C
new file mode 100644
index 0000000..eec7d34
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp0x/initlist-vect2.C
@@ -0,0 +1,16 @@
+// PR c++/108195
+// { dg-do run { target c++11 } }
+
+#include <vector>
+
+struct S
+{
+  S(bool) {}
+};
+
+int main()
+{
+  std::vector<S> v = { true, false, true };
+  if (v.size() != 3)
+    __builtin_abort ();
+}
diff --git a/gcc/testsuite/g++.dg/cpp0x/move2.C b/gcc/testsuite/g++.dg/cpp0x/move2.C
new file mode 100644
index 0000000..b8c8683
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp0x/move2.C
@@ -0,0 +1,14 @@
+// PR c++/107267
+// { dg-do compile { target c++11 } }
+// { dg-additional-options -ffold-simple-inlines }
+
+namespace std {
+  template<typename _Tp> _Tp &&move(_Tp &&);
+}
+
+struct FindResult {
+  FindResult();
+  int result;
+};
+
+FindResult pop_ret = std::move(FindResult());
diff --git a/gcc/testsuite/g++.dg/cpp0x/udlit-error1.C b/gcc/testsuite/g++.dg/cpp0x/udlit-error1.C
new file mode 100644
index 0000000..66e300e
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp0x/udlit-error1.C
@@ -0,0 +1,21 @@
+// PR c++/105300
+// { dg-do compile { target c++11 } }
+
+void operator""_x(const char *, decltype(sizeof(0)));
+
+#include ""_x		  // { dg-error "include expects" }
+#line ""_x		  // { dg-error "not a positive integer" }
+#if __has_include(""_x)	  // { dg-error "requires a header-name" }
+#endif
+
+#pragma message "hi"_x	  // { dg-warning "string literal with user-defined suffix is invalid in this context" }
+
+extern "C"_x { void g(); } // { dg-error "before user-defined string literal" }
+static_assert(true, "foo"_x); // { dg-error "string literal with user-defined suffix is invalid in this context|expected" }
+
+[[deprecated("oof"_x)]]
+void
+lol () // { dg-error "not a string" }
+{
+  asm (""_x); // { dg-error "string literal with user-defined suffix is invalid in this context" }
+}
diff --git a/gcc/testsuite/g++.dg/cpp1z/decomp57.C b/gcc/testsuite/g++.dg/cpp1z/decomp57.C
new file mode 100644
index 0000000..923862e
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp1z/decomp57.C
@@ -0,0 +1,27 @@
+// PR c++/108474
+// { dg-do link { target c++17 } }
+
+struct T { int i, j; };
+T h;
+auto [i, j] = h;
+int &r = i;
+int s = i;
+int *t = &i;
+
+void
+foo (int **p, int *q)
+{
+  static int &u = i;
+  static int v = i;
+  static int *w = &i;
+  int &x = i;
+  int y = i;
+  int *z = &i;
+  *p = &i;
+  *q = i;
+}
+
+int
+main ()
+{
+}
diff --git a/gcc/testsuite/g++.dg/cpp1z/decomp58.C b/gcc/testsuite/g++.dg/cpp1z/decomp58.C
new file mode 100644
index 0000000..b260437
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp1z/decomp58.C
@@ -0,0 +1,39 @@
+// PR c++/108474
+// { dg-do link { target c++17 } }
+
+namespace std {
+  template <typename T> struct tuple_size;
+  template <int, typename> struct tuple_element;
+}
+
+struct A {
+  int i;
+  template <int I> int& get() { return i; }
+};
+
+template <> struct std::tuple_size <A> { static const int value = 2; };
+template <int I> struct std::tuple_element <I, A> { using type = int; };
+
+struct A a;
+auto [i, j] = a;
+int &r = i;
+int s = i;
+int *t = &i;
+
+void
+foo (int **p, int *q)
+{
+  static int &u = i;
+  static int v = i;
+  static int *w = &i;
+  int &x = i;
+  int y = i;
+  int *z = &i;
+  *p = &i;
+  *q = i;
+}
+
+int
+main ()
+{
+}
diff --git a/gcc/testsuite/g++.dg/cpp23/static-operator-call5.C b/gcc/testsuite/g++.dg/cpp23/static-operator-call5.C
new file mode 100644
index 0000000..ecbb843
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp23/static-operator-call5.C
@@ -0,0 +1,13 @@
+// PR c++/108525
+// { dg-do compile { target c++23 } }
+
+auto b = [](...) static { return 1; };
+auto foo () { return b (); }
+// PR c++/108526
+// { dg-do compile { target c++23 } }
+
+template<class> void f()
+{
+  auto a = [] (auto x) static { return x; };
+}
+template void f<int>();
diff --git a/gcc/testsuite/g++.dg/cpp23/subscript12.C b/gcc/testsuite/g++.dg/cpp23/subscript12.C
new file mode 100644
index 0000000..49cd8a6
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp23/subscript12.C
@@ -0,0 +1,34 @@
+// PR c++/108437
+// { dg-do run { target c++23 } }
+
+struct S { static int &operator[] (int x) { static int a[2]; return a[x]; } };
+struct U { static int &operator[] (int x, int y, int z) { static int a[2]; return a[x + y + z]; } };
+struct V { static int &operator[] () { static int a; return a; } };
+
+template <class T, class W, class X> void
+foo ()
+{
+  S s;
+  s[0]++;
+  T t;
+  t[0]++;
+  U u;
+  u[0, 0, 0]++;
+  V v;
+  v[]++;
+  W w;
+  w[0, 0, 0]++;
+  X x;
+  x[]++;
+}
+
+int
+main ()
+{
+  S::operator[] (0) = 1;
+  U::operator[] (0, 0, 0) = 2;
+  V::operator[] () = 3;
+  foo <S, U, V> ();
+  if (S::operator[] (0) != 3 || U::operator[] (0, 0, 0) != 4 || V::operator[] () != 5)
+    __builtin_abort ();
+}
diff --git a/gcc/testsuite/g++.dg/cpp23/subscript13.C b/gcc/testsuite/g++.dg/cpp23/subscript13.C
new file mode 100644
index 0000000..3fb3b49
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp23/subscript13.C
@@ -0,0 +1,43 @@
+// PR c++/108437
+// { dg-do run { target c++23 } }
+
+struct S { static int &operator[] (int x) { static int a[2]; return a[x]; } };
+struct U { static int &operator[] (int x, int y, int z) { static int a[2]; return a[x + y + z]; } };
+struct V { static int &operator[] () { static int a; return a; } };
+int cnt;
+
+template <typename T>
+T &
+bar (T &x)
+{
+  ++cnt;
+  return x;
+}
+
+template <class T, class W, class X> void
+foo ()
+{
+  S s;
+  bar (s)[0]++;
+  T t;
+  bar (t)[0]++;
+  U u;
+  bar (u)[0, 0, 0]++;
+  V v;
+  bar (v)[]++;
+  W w;
+  bar (w)[0, 0, 0]++;
+  X x;
+  bar (x)[]++;
+}
+
+int
+main ()
+{
+  S::operator[] (0) = 1;
+  U::operator[] (0, 0, 0) = 2;
+  V::operator[] () = 3;
+  foo <S, U, V> ();
+  if (S::operator[] (0) != 3 || U::operator[] (0, 0, 0) != 4 || V::operator[] () != 5 || cnt != 6)
+    __builtin_abort ();
+}
diff --git a/gcc/testsuite/g++.dg/ext/builtin-shufflevector-5.C b/gcc/testsuite/g++.dg/ext/builtin-shufflevector-5.C
new file mode 100644
index 0000000..06472b8
--- /dev/null
+++ b/gcc/testsuite/g++.dg/ext/builtin-shufflevector-5.C
@@ -0,0 +1,14 @@
+// PR c++/107303
+// { dg-options "-Wno-psabi" }
+
+typedef __attribute__((__vector_size__ (2))) unsigned short U;
+typedef __attribute__((__vector_size__ (8))) unsigned short V;
+
+U u0, u1, u2;
+V v;
+
+void
+foo (void)
+{
+  u0 *= +__builtin_shufflevector (__builtin_shufflevector (u1, v, 3, 1), u2, 0);
+}
diff --git a/gcc/testsuite/g++.dg/ext/pragma1.C b/gcc/testsuite/g++.dg/ext/pragma1.C
new file mode 100644
index 0000000..bb258da
--- /dev/null
+++ b/gcc/testsuite/g++.dg/ext/pragma1.C
@@ -0,0 +1,4 @@
+// PR c++/108504
+
+"1"				// { dg-error "" }
+#pragma GCC diagnostic push
diff --git a/gcc/testsuite/g++.dg/gomp/pr108503.C b/gcc/testsuite/g++.dg/gomp/pr108503.C
new file mode 100644
index 0000000..906d41b
--- /dev/null
+++ b/gcc/testsuite/g++.dg/gomp/pr108503.C
@@ -0,0 +1,27 @@
+// PR c++/108503
+// { dg-do compile { target c++17 } }
+// { dg-additional-options "-Wall" }
+
+namespace std {
+  template <typename T> struct tuple_size;
+  template <int, typename> struct tuple_element;
+}
+struct A {
+  template <int I> int get () { return 1; }
+};
+template <> struct std::tuple_size <A> { static const int value = 3; };
+template <int I> struct std::tuple_element <I, A> { using type = int; };
+
+struct B {
+  A *begin ();
+  A *end ();
+};
+
+void
+foo (B a)
+{
+  #pragma omp for collapse(2)
+  for (auto [i, j, k] : a)
+    for (int l = i; l < j; l += k)	// { dg-error "initializer expression refers to iteration variable 'i'" }
+      ;					// { dg-error "condition expression refers to iteration variable 'j'" "" { target *-*-* } .-1 }
+}					// { dg-error "increment expression refers to iteration variable 'k'" "" { target *-*-* } .-2 }
diff --git a/gcc/testsuite/g++.dg/init/lifetime4.C b/gcc/testsuite/g++.dg/init/lifetime4.C
new file mode 100644
index 0000000..4106af7
--- /dev/null
+++ b/gcc/testsuite/g++.dg/init/lifetime4.C
@@ -0,0 +1,39 @@
+// PR c++/53288
+// { dg-do compile { target c++11 } }
+
+struct B {
+   B(int data) : _data(data) { }
+   ~B() { }
+
+   int _data;
+
+private:
+   B() = delete;
+   B(const B &) = delete;
+   B(B &&) = delete;
+};
+
+int c,d;
+struct A {
+   B b;
+   A(int data) : b(data) { ++c; }
+   ~A() { ++d; }
+
+private:
+   A() = delete;
+   A(const A &) = delete;
+   A(A &&) = delete;
+};
+
+template <class T>
+void f(T t) {
+  const B &b = A(1).*t;
+  if (d) __builtin_abort ();
+}
+
+int main() {
+  const B &b = A(1).*(&A::b);
+  if (d) __builtin_abort ();
+
+  f(&A::b);
+}
diff --git a/gcc/testsuite/g++.dg/init/new51.C b/gcc/testsuite/g++.dg/init/new51.C
new file mode 100644
index 0000000..89c0f87
--- /dev/null
+++ b/gcc/testsuite/g++.dg/init/new51.C
@@ -0,0 +1,11 @@
+// PR c++/107329
+
+typedef __SIZE_TYPE__ size_t;
+struct RexxClass {
+  void *operator new(size_t, size_t, const char *, RexxClass *,
+                     RexxClass *);
+  void operator delete(void *, size_t, const char *, RexxClass *,
+                       RexxClass *);
+  RexxClass();
+};
+void createInstance() { new (sizeof(RexxClass), "", 0, 0) RexxClass; }
diff --git a/gcc/testsuite/g++.dg/init/pr53932.C b/gcc/testsuite/g++.dg/init/pr53932.C
new file mode 100644
index 0000000..3b129e7
--- /dev/null
+++ b/gcc/testsuite/g++.dg/init/pr53932.C
@@ -0,0 +1,25 @@
+// PR c++/53932
+// { dg-do link }
+
+static union { int i; };
+int &r = i;
+int s = i;
+int *t = &i;
+
+void
+foo (int **p, int *q)
+{
+  static int &u = i;
+  static int v = i;
+  static int *w = &i;
+  int &x = i;
+  int y = i;
+  int *z = &i;
+  *p = &i;
+  *q = i;
+}
+
+int
+main ()
+{
+}
diff --git a/gcc/testsuite/g++.dg/template/explicit-instantiation5.C b/gcc/testsuite/g++.dg/template/explicit-instantiation5.C
new file mode 100644
index 0000000..7bc007c
--- /dev/null
+++ b/gcc/testsuite/g++.dg/template/explicit-instantiation5.C
@@ -0,0 +1,15 @@
+// PR c++/108496
+
+struct S { long a, b, c; } s;
+
+template <int, typename>
+S foo (S);
+
+template <>
+S
+foo <0, long> (S)
+{
+  return s;
+}
+
+template S foo <0, long> (S);
diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr106077.C b/gcc/testsuite/g++.dg/tree-ssa/pr106077.C
new file mode 100644
index 0000000..2c2f729
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tree-ssa/pr106077.C
@@ -0,0 +1,22 @@
+// { dg-do compile }
+// { dg-options "-O2 -fno-ipa-cp -fdump-tree-optimized" }
+short e,f;
+static __attribute__ ((noinline))
+int a(int *b)
+{
+        return *b;
+}
+static __attribute__ ((noinline))
+__attribute__ ((optimize("non-call-exceptions")))
+int wrap(int *b,int e, int f)
+{
+        e/=f;
+        return a(b)+e;
+}
+
+int
+t()
+{
+        return wrap(0,1,0);
+}
+// { dg-final { scan-tree-dump-not "builtin_trap" "optimized" } }
diff --git a/gcc/testsuite/g++.dg/warn/Wunused-value-1.C b/gcc/testsuite/g++.dg/warn/Wunused-value-1.C
new file mode 100644
index 0000000..2ba5587
--- /dev/null
+++ b/gcc/testsuite/g++.dg/warn/Wunused-value-1.C
@@ -0,0 +1,12 @@
+// PR c++/107797
+// { dg-do compile { target c++11 } }
+// { dg-options "-Wunused" }
+
+void
+g ()
+{
+  (long) new int{};
+  long(new int{});
+  (long) new int();
+  long(new int());
+}
diff --git a/gcc/testsuite/g++.target/aarch64/bitfield-abi-warning-align16-O2-extra.C b/gcc/testsuite/g++.target/aarch64/bitfield-abi-warning-align16-O2-extra.C
index 443cd45..52f9cdd 100644
--- a/gcc/testsuite/g++.target/aarch64/bitfield-abi-warning-align16-O2-extra.C
+++ b/gcc/testsuite/g++.target/aarch64/bitfield-abi-warning-align16-O2-extra.C
@@ -1,5 +1,5 @@
 /* { dg-do compile } */
-/* { dg-options "-O2 -save-temps -Wno-narrowing" } */
+/* { dg-options "-O2 -fno-stack-protector -save-temps -Wno-narrowing" } */
 
 #define ALIGN 16
 //#define EXTRA
diff --git a/gcc/testsuite/g++.target/aarch64/bitfield-abi-warning-align16-O2.C b/gcc/testsuite/g++.target/aarch64/bitfield-abi-warning-align16-O2.C
index 76a7e3d..9ff4e46 100644
--- a/gcc/testsuite/g++.target/aarch64/bitfield-abi-warning-align16-O2.C
+++ b/gcc/testsuite/g++.target/aarch64/bitfield-abi-warning-align16-O2.C
@@ -1,5 +1,5 @@
 /* { dg-do compile } */
-/* { dg-options "-O2 -save-temps -Wno-narrowing" } */
+/* { dg-options "-O2 -fno-stack-protector -save-temps -Wno-narrowing" } */
 
 #define ALIGN 16
 #define EXTRA
diff --git a/gcc/testsuite/g++.target/aarch64/bitfield-abi-warning-align32-O2-extra.C b/gcc/testsuite/g++.target/aarch64/bitfield-abi-warning-align32-O2-extra.C
index 6f8f54f..55dcbfe 100644
--- a/gcc/testsuite/g++.target/aarch64/bitfield-abi-warning-align32-O2-extra.C
+++ b/gcc/testsuite/g++.target/aarch64/bitfield-abi-warning-align32-O2-extra.C
@@ -1,5 +1,5 @@
 /* { dg-do compile } */
-/* { dg-options "-O2 -save-temps -Wno-narrowing" } */
+/* { dg-options "-O2 -fno-stack-protector -save-temps -Wno-narrowing" } */
 
 #define ALIGN 32
 //#define EXTRA
diff --git a/gcc/testsuite/g++.target/aarch64/bitfield-abi-warning-align32-O2.C b/gcc/testsuite/g++.target/aarch64/bitfield-abi-warning-align32-O2.C
index 6b8ad5f..6bb8778 100644
--- a/gcc/testsuite/g++.target/aarch64/bitfield-abi-warning-align32-O2.C
+++ b/gcc/testsuite/g++.target/aarch64/bitfield-abi-warning-align32-O2.C
@@ -1,5 +1,5 @@
 /* { dg-do compile } */
-/* { dg-options "-O2 -save-temps -Wno-narrowing" } */
+/* { dg-options "-O2 -fno-stack-protector -save-temps -Wno-narrowing" } */
 
 #define ALIGN 32
 #define EXTRA
diff --git a/gcc/testsuite/g++.target/aarch64/bitfield-abi-warning-align8-O2.C b/gcc/testsuite/g++.target/aarch64/bitfield-abi-warning-align8-O2.C
index b1764d9..41bcc89 100644
--- a/gcc/testsuite/g++.target/aarch64/bitfield-abi-warning-align8-O2.C
+++ b/gcc/testsuite/g++.target/aarch64/bitfield-abi-warning-align8-O2.C
@@ -1,5 +1,5 @@
 /* { dg-do compile } */
-/* { dg-options "-O2 -save-temps -Wno-narrowing" } */
+/* { dg-options "-O2 -fno-stack-protector -save-temps -Wno-narrowing" } */
 
 #define ALIGN 8
 #define EXTRA
diff --git a/gcc/testsuite/g++.target/aarch64/sve/pr99766.C b/gcc/testsuite/g++.target/aarch64/sve/pr99766.C
index 0ca8aee..528d9dd 100644
--- a/gcc/testsuite/g++.target/aarch64/sve/pr99766.C
+++ b/gcc/testsuite/g++.target/aarch64/sve/pr99766.C
@@ -1,5 +1,5 @@
 /* { dg-do compile } */
-/* { dg-additional-options "-O3 -march=armv8.2-a+sve" } */
+/* { dg-additional-options "-O3 -march=armv8.2-a+sve -w" } */
 typedef float a __attribute__((__mode__(HF)));
 typedef struct {
   a b;
diff --git a/gcc/testsuite/g++.target/arm/pac-1.C b/gcc/testsuite/g++.target/arm/pac-1.C
new file mode 100644
index 0000000..f671a27
--- /dev/null
+++ b/gcc/testsuite/g++.target/arm/pac-1.C
@@ -0,0 +1,35 @@
+/* Check that GCC does .save and .cfi_offset directives with RA_AUTH_CODE pseudo hard-register.  */
+/* { dg-do compile } */
+/* { dg-skip-if "avoid conflicting multilib options" { *-*-* } { "-marm" "-mcpu=*" } } */
+/* { dg-options "-march=armv8.1-m.main+mve+pacbti -mbranch-protection=pac-ret -mthumb -mfloat-abi=hard -g -O0" } */
+
+__attribute__((noinline)) void
+fn1 (int a, int b, int c)
+{
+  if (a != b + c)
+    __builtin_abort ();
+  else
+    throw b+c;
+}
+
+int main ()
+{
+  int a = 120;
+  try
+    {
+      fn1 (a, 40, 80);
+    }
+  catch (int x)
+    {
+      if (x != a)
+        __builtin_abort ();
+      else
+	return 0;
+    }
+}
+
+/* { dg-final { scan-assembler-times "pac	ip, lr, sp" 2 } } */
+/* { dg-final { scan-assembler-times "\.cfi_register 143, 12" 2 } } */
+/* { dg-final { scan-assembler-times "\.save {r7, ra_auth_code, lr}" 1 } } */
+/* { dg-final { scan-assembler-times "\.cfi_offset 143, -8" 2 } } */
+/* { dg-final { scan-assembler-times "\.save {r4, r7, ra_auth_code, lr}" 1 } } */
diff --git a/gcc/testsuite/g++.target/i386/pr105980.C b/gcc/testsuite/g++.target/i386/pr105980.C
new file mode 100644
index 0000000..d8dbc33
--- /dev/null
+++ b/gcc/testsuite/g++.target/i386/pr105980.C
@@ -0,0 +1,8 @@
+// { dg-do assemble { target { fpic } } }
+// { dg-options "-O0 -fpic -mforce-indirect-call" }
+
+struct A {
+  virtual ~A();
+};
+struct B : virtual A {};
+void bar() { B(); }
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/riscv_vector.h b/gcc/testsuite/g++.target/riscv/rvv/base/riscv_vector.h
new file mode 100644
index 0000000..fbb4858f
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/riscv_vector.h
@@ -0,0 +1,11 @@
+/* Wrapper of riscv_vector.h, prevent riscv_vector.h including stdint.h from
+   C library, that might cause problem on testing RV32 related testcase when
+   we disable multilib.  */
+#ifndef _RISCV_VECTOR_WRAP_H
+
+#define _GCC_WRAP_STDINT_H
+#include "stdint-gcc.h"
+#include_next <riscv_vector.h>
+#define _RISCV_VECTOR_WRAP_H
+
+#endif
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vle-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vle-1.C
new file mode 100644
index 0000000..e06f62a
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vle-1.C
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vle8(vbool64_t mask,int8_t* base,size_t vl)
+{
+  return __riscv_vle8(mask,base,vl);
+}
+
+vint8mf4_t
+test___riscv_vle8(vbool32_t mask,int8_t* base,size_t vl)
+{
+  return __riscv_vle8(mask,base,vl);
+}
+
+vint8mf2_t
+test___riscv_vle8(vbool16_t mask,int8_t* base,size_t vl)
+{
+  return __riscv_vle8(mask,base,vl);
+}
+
+vint8m1_t
+test___riscv_vle8(vbool8_t mask,int8_t* base,size_t vl)
+{
+  return __riscv_vle8(mask,base,vl);
+}
+
+vint8m2_t
+test___riscv_vle8(vbool4_t mask,int8_t* base,size_t vl)
+{
+  return __riscv_vle8(mask,base,vl);
+}
+
+vint8m4_t
+test___riscv_vle8(vbool2_t mask,int8_t* base,size_t vl)
+{
+  return __riscv_vle8(mask,base,vl);
+}
+
+vint8m8_t
+test___riscv_vle8(vbool1_t mask,int8_t* base,size_t vl)
+{
+  return __riscv_vle8(mask,base,vl);
+}
+
+vuint8mf8_t
+test___riscv_vle8(vbool64_t mask,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8(mask,base,vl);
+}
+
+vuint8mf4_t
+test___riscv_vle8(vbool32_t mask,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8(mask,base,vl);
+}
+
+vuint8mf2_t
+test___riscv_vle8(vbool16_t mask,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8(mask,base,vl);
+}
+
+vuint8m1_t
+test___riscv_vle8(vbool8_t mask,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8(mask,base,vl);
+}
+
+vuint8m2_t
+test___riscv_vle8(vbool4_t mask,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8(mask,base,vl);
+}
+
+vuint8m4_t
+test___riscv_vle8(vbool2_t mask,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8(mask,base,vl);
+}
+
+vuint8m8_t
+test___riscv_vle8(vbool1_t mask,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8(mask,base,vl);
+}
+
+vint16mf4_t
+test___riscv_vle16(vbool64_t mask,int16_t* base,size_t vl)
+{
+  return __riscv_vle16(mask,base,vl);
+}
+
+vint16mf2_t
+test___riscv_vle16(vbool32_t mask,int16_t* base,size_t vl)
+{
+  return __riscv_vle16(mask,base,vl);
+}
+
+vint16m1_t
+test___riscv_vle16(vbool16_t mask,int16_t* base,size_t vl)
+{
+  return __riscv_vle16(mask,base,vl);
+}
+
+vint16m2_t
+test___riscv_vle16(vbool8_t mask,int16_t* base,size_t vl)
+{
+  return __riscv_vle16(mask,base,vl);
+}
+
+vint16m4_t
+test___riscv_vle16(vbool4_t mask,int16_t* base,size_t vl)
+{
+  return __riscv_vle16(mask,base,vl);
+}
+
+vint16m8_t
+test___riscv_vle16(vbool2_t mask,int16_t* base,size_t vl)
+{
+  return __riscv_vle16(mask,base,vl);
+}
+
+vuint16mf4_t
+test___riscv_vle16(vbool64_t mask,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16(mask,base,vl);
+}
+
+vuint16mf2_t
+test___riscv_vle16(vbool32_t mask,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16(mask,base,vl);
+}
+
+vuint16m1_t
+test___riscv_vle16(vbool16_t mask,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16(mask,base,vl);
+}
+
+vuint16m2_t
+test___riscv_vle16(vbool8_t mask,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16(mask,base,vl);
+}
+
+vuint16m4_t
+test___riscv_vle16(vbool4_t mask,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16(mask,base,vl);
+}
+
+vuint16m8_t
+test___riscv_vle16(vbool2_t mask,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16(mask,base,vl);
+}
+
+vint32mf2_t
+test___riscv_vle32(vbool64_t mask,int32_t* base,size_t vl)
+{
+  return __riscv_vle32(mask,base,vl);
+}
+
+vint32m1_t
+test___riscv_vle32(vbool32_t mask,int32_t* base,size_t vl)
+{
+  return __riscv_vle32(mask,base,vl);
+}
+
+vint32m2_t
+test___riscv_vle32(vbool16_t mask,int32_t* base,size_t vl)
+{
+  return __riscv_vle32(mask,base,vl);
+}
+
+vint32m4_t
+test___riscv_vle32(vbool8_t mask,int32_t* base,size_t vl)
+{
+  return __riscv_vle32(mask,base,vl);
+}
+
+vint32m8_t
+test___riscv_vle32(vbool4_t mask,int32_t* base,size_t vl)
+{
+  return __riscv_vle32(mask,base,vl);
+}
+
+vuint32mf2_t
+test___riscv_vle32(vbool64_t mask,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32(mask,base,vl);
+}
+
+vuint32m1_t
+test___riscv_vle32(vbool32_t mask,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32(mask,base,vl);
+}
+
+vuint32m2_t
+test___riscv_vle32(vbool16_t mask,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32(mask,base,vl);
+}
+
+vuint32m4_t
+test___riscv_vle32(vbool8_t mask,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32(mask,base,vl);
+}
+
+vuint32m8_t
+test___riscv_vle32(vbool4_t mask,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32(mask,base,vl);
+}
+
+vfloat32mf2_t
+test___riscv_vle32(vbool64_t mask,float* base,size_t vl)
+{
+  return __riscv_vle32(mask,base,vl);
+}
+
+vfloat32m1_t
+test___riscv_vle32(vbool32_t mask,float* base,size_t vl)
+{
+  return __riscv_vle32(mask,base,vl);
+}
+
+vfloat32m2_t
+test___riscv_vle32(vbool16_t mask,float* base,size_t vl)
+{
+  return __riscv_vle32(mask,base,vl);
+}
+
+vfloat32m4_t
+test___riscv_vle32(vbool8_t mask,float* base,size_t vl)
+{
+  return __riscv_vle32(mask,base,vl);
+}
+
+vfloat32m8_t
+test___riscv_vle32(vbool4_t mask,float* base,size_t vl)
+{
+  return __riscv_vle32(mask,base,vl);
+}
+
+vint64m1_t
+test___riscv_vle64(vbool64_t mask,int64_t* base,size_t vl)
+{
+  return __riscv_vle64(mask,base,vl);
+}
+
+vint64m2_t
+test___riscv_vle64(vbool32_t mask,int64_t* base,size_t vl)
+{
+  return __riscv_vle64(mask,base,vl);
+}
+
+vint64m4_t
+test___riscv_vle64(vbool16_t mask,int64_t* base,size_t vl)
+{
+  return __riscv_vle64(mask,base,vl);
+}
+
+vint64m8_t
+test___riscv_vle64(vbool8_t mask,int64_t* base,size_t vl)
+{
+  return __riscv_vle64(mask,base,vl);
+}
+
+vuint64m1_t
+test___riscv_vle64(vbool64_t mask,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64(mask,base,vl);
+}
+
+vuint64m2_t
+test___riscv_vle64(vbool32_t mask,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64(mask,base,vl);
+}
+
+vuint64m4_t
+test___riscv_vle64(vbool16_t mask,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64(mask,base,vl);
+}
+
+vuint64m8_t
+test___riscv_vle64(vbool8_t mask,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64(mask,base,vl);
+}
+
+vfloat64m1_t
+test___riscv_vle64(vbool64_t mask,double* base,size_t vl)
+{
+  return __riscv_vle64(mask,base,vl);
+}
+
+vfloat64m2_t
+test___riscv_vle64(vbool32_t mask,double* base,size_t vl)
+{
+  return __riscv_vle64(mask,base,vl);
+}
+
+vfloat64m4_t
+test___riscv_vle64(vbool16_t mask,double* base,size_t vl)
+{
+  return __riscv_vle64(mask,base,vl);
+}
+
+vfloat64m8_t
+test___riscv_vle64(vbool8_t mask,double* base,size_t vl)
+{
+  return __riscv_vle64(mask,base,vl);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vle_tu-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vle_tu-1.C
new file mode 100644
index 0000000..1408f98
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vle_tu-1.C
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vle8_tu(vint8mf8_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_tu(merge,base,vl);
+}
+
+vint8mf4_t
+test___riscv_vle8_tu(vint8mf4_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_tu(merge,base,vl);
+}
+
+vint8mf2_t
+test___riscv_vle8_tu(vint8mf2_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_tu(merge,base,vl);
+}
+
+vint8m1_t
+test___riscv_vle8_tu(vint8m1_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_tu(merge,base,vl);
+}
+
+vint8m2_t
+test___riscv_vle8_tu(vint8m2_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_tu(merge,base,vl);
+}
+
+vint8m4_t
+test___riscv_vle8_tu(vint8m4_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_tu(merge,base,vl);
+}
+
+vint8m8_t
+test___riscv_vle8_tu(vint8m8_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_tu(merge,base,vl);
+}
+
+vuint8mf8_t
+test___riscv_vle8_tu(vuint8mf8_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_tu(merge,base,vl);
+}
+
+vuint8mf4_t
+test___riscv_vle8_tu(vuint8mf4_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_tu(merge,base,vl);
+}
+
+vuint8mf2_t
+test___riscv_vle8_tu(vuint8mf2_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_tu(merge,base,vl);
+}
+
+vuint8m1_t
+test___riscv_vle8_tu(vuint8m1_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_tu(merge,base,vl);
+}
+
+vuint8m2_t
+test___riscv_vle8_tu(vuint8m2_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_tu(merge,base,vl);
+}
+
+vuint8m4_t
+test___riscv_vle8_tu(vuint8m4_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_tu(merge,base,vl);
+}
+
+vuint8m8_t
+test___riscv_vle8_tu(vuint8m8_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_tu(merge,base,vl);
+}
+
+vint16mf4_t
+test___riscv_vle16_tu(vint16mf4_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_tu(merge,base,vl);
+}
+
+vint16mf2_t
+test___riscv_vle16_tu(vint16mf2_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_tu(merge,base,vl);
+}
+
+vint16m1_t
+test___riscv_vle16_tu(vint16m1_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_tu(merge,base,vl);
+}
+
+vint16m2_t
+test___riscv_vle16_tu(vint16m2_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_tu(merge,base,vl);
+}
+
+vint16m4_t
+test___riscv_vle16_tu(vint16m4_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_tu(merge,base,vl);
+}
+
+vint16m8_t
+test___riscv_vle16_tu(vint16m8_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_tu(merge,base,vl);
+}
+
+vuint16mf4_t
+test___riscv_vle16_tu(vuint16mf4_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_tu(merge,base,vl);
+}
+
+vuint16mf2_t
+test___riscv_vle16_tu(vuint16mf2_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_tu(merge,base,vl);
+}
+
+vuint16m1_t
+test___riscv_vle16_tu(vuint16m1_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_tu(merge,base,vl);
+}
+
+vuint16m2_t
+test___riscv_vle16_tu(vuint16m2_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_tu(merge,base,vl);
+}
+
+vuint16m4_t
+test___riscv_vle16_tu(vuint16m4_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_tu(merge,base,vl);
+}
+
+vuint16m8_t
+test___riscv_vle16_tu(vuint16m8_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_tu(merge,base,vl);
+}
+
+vint32mf2_t
+test___riscv_vle32_tu(vint32mf2_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_tu(merge,base,vl);
+}
+
+vint32m1_t
+test___riscv_vle32_tu(vint32m1_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_tu(merge,base,vl);
+}
+
+vint32m2_t
+test___riscv_vle32_tu(vint32m2_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_tu(merge,base,vl);
+}
+
+vint32m4_t
+test___riscv_vle32_tu(vint32m4_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_tu(merge,base,vl);
+}
+
+vint32m8_t
+test___riscv_vle32_tu(vint32m8_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_tu(merge,base,vl);
+}
+
+vuint32mf2_t
+test___riscv_vle32_tu(vuint32mf2_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_tu(merge,base,vl);
+}
+
+vuint32m1_t
+test___riscv_vle32_tu(vuint32m1_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_tu(merge,base,vl);
+}
+
+vuint32m2_t
+test___riscv_vle32_tu(vuint32m2_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_tu(merge,base,vl);
+}
+
+vuint32m4_t
+test___riscv_vle32_tu(vuint32m4_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_tu(merge,base,vl);
+}
+
+vuint32m8_t
+test___riscv_vle32_tu(vuint32m8_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_tu(merge,base,vl);
+}
+
+vfloat32mf2_t
+test___riscv_vle32_tu(vfloat32mf2_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_tu(merge,base,vl);
+}
+
+vfloat32m1_t
+test___riscv_vle32_tu(vfloat32m1_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_tu(merge,base,vl);
+}
+
+vfloat32m2_t
+test___riscv_vle32_tu(vfloat32m2_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_tu(merge,base,vl);
+}
+
+vfloat32m4_t
+test___riscv_vle32_tu(vfloat32m4_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_tu(merge,base,vl);
+}
+
+vfloat32m8_t
+test___riscv_vle32_tu(vfloat32m8_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_tu(merge,base,vl);
+}
+
+vint64m1_t
+test___riscv_vle64_tu(vint64m1_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_tu(merge,base,vl);
+}
+
+vint64m2_t
+test___riscv_vle64_tu(vint64m2_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_tu(merge,base,vl);
+}
+
+vint64m4_t
+test___riscv_vle64_tu(vint64m4_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_tu(merge,base,vl);
+}
+
+vint64m8_t
+test___riscv_vle64_tu(vint64m8_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_tu(merge,base,vl);
+}
+
+vuint64m1_t
+test___riscv_vle64_tu(vuint64m1_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_tu(merge,base,vl);
+}
+
+vuint64m2_t
+test___riscv_vle64_tu(vuint64m2_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_tu(merge,base,vl);
+}
+
+vuint64m4_t
+test___riscv_vle64_tu(vuint64m4_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_tu(merge,base,vl);
+}
+
+vuint64m8_t
+test___riscv_vle64_tu(vuint64m8_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_tu(merge,base,vl);
+}
+
+vfloat64m1_t
+test___riscv_vle64_tu(vfloat64m1_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_tu(merge,base,vl);
+}
+
+vfloat64m2_t
+test___riscv_vle64_tu(vfloat64m2_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_tu(merge,base,vl);
+}
+
+vfloat64m4_t
+test___riscv_vle64_tu(vfloat64m4_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_tu(merge,base,vl);
+}
+
+vfloat64m8_t
+test___riscv_vle64_tu(vfloat64m8_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_tu(merge,base,vl);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vle_tum-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vle_tum-1.C
new file mode 100644
index 0000000..7449744
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vle_tum-1.C
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vle8_tum(vbool64_t mask,vint8mf8_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_tum(mask,merge,base,vl);
+}
+
+vint8mf4_t
+test___riscv_vle8_tum(vbool32_t mask,vint8mf4_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_tum(mask,merge,base,vl);
+}
+
+vint8mf2_t
+test___riscv_vle8_tum(vbool16_t mask,vint8mf2_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_tum(mask,merge,base,vl);
+}
+
+vint8m1_t
+test___riscv_vle8_tum(vbool8_t mask,vint8m1_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_tum(mask,merge,base,vl);
+}
+
+vint8m2_t
+test___riscv_vle8_tum(vbool4_t mask,vint8m2_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_tum(mask,merge,base,vl);
+}
+
+vint8m4_t
+test___riscv_vle8_tum(vbool2_t mask,vint8m4_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_tum(mask,merge,base,vl);
+}
+
+vint8m8_t
+test___riscv_vle8_tum(vbool1_t mask,vint8m8_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_tum(mask,merge,base,vl);
+}
+
+vuint8mf8_t
+test___riscv_vle8_tum(vbool64_t mask,vuint8mf8_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_tum(mask,merge,base,vl);
+}
+
+vuint8mf4_t
+test___riscv_vle8_tum(vbool32_t mask,vuint8mf4_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_tum(mask,merge,base,vl);
+}
+
+vuint8mf2_t
+test___riscv_vle8_tum(vbool16_t mask,vuint8mf2_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_tum(mask,merge,base,vl);
+}
+
+vuint8m1_t
+test___riscv_vle8_tum(vbool8_t mask,vuint8m1_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_tum(mask,merge,base,vl);
+}
+
+vuint8m2_t
+test___riscv_vle8_tum(vbool4_t mask,vuint8m2_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_tum(mask,merge,base,vl);
+}
+
+vuint8m4_t
+test___riscv_vle8_tum(vbool2_t mask,vuint8m4_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_tum(mask,merge,base,vl);
+}
+
+vuint8m8_t
+test___riscv_vle8_tum(vbool1_t mask,vuint8m8_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_tum(mask,merge,base,vl);
+}
+
+vint16mf4_t
+test___riscv_vle16_tum(vbool64_t mask,vint16mf4_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_tum(mask,merge,base,vl);
+}
+
+vint16mf2_t
+test___riscv_vle16_tum(vbool32_t mask,vint16mf2_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_tum(mask,merge,base,vl);
+}
+
+vint16m1_t
+test___riscv_vle16_tum(vbool16_t mask,vint16m1_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_tum(mask,merge,base,vl);
+}
+
+vint16m2_t
+test___riscv_vle16_tum(vbool8_t mask,vint16m2_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_tum(mask,merge,base,vl);
+}
+
+vint16m4_t
+test___riscv_vle16_tum(vbool4_t mask,vint16m4_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_tum(mask,merge,base,vl);
+}
+
+vint16m8_t
+test___riscv_vle16_tum(vbool2_t mask,vint16m8_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_tum(mask,merge,base,vl);
+}
+
+vuint16mf4_t
+test___riscv_vle16_tum(vbool64_t mask,vuint16mf4_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_tum(mask,merge,base,vl);
+}
+
+vuint16mf2_t
+test___riscv_vle16_tum(vbool32_t mask,vuint16mf2_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_tum(mask,merge,base,vl);
+}
+
+vuint16m1_t
+test___riscv_vle16_tum(vbool16_t mask,vuint16m1_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_tum(mask,merge,base,vl);
+}
+
+vuint16m2_t
+test___riscv_vle16_tum(vbool8_t mask,vuint16m2_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_tum(mask,merge,base,vl);
+}
+
+vuint16m4_t
+test___riscv_vle16_tum(vbool4_t mask,vuint16m4_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_tum(mask,merge,base,vl);
+}
+
+vuint16m8_t
+test___riscv_vle16_tum(vbool2_t mask,vuint16m8_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_tum(mask,merge,base,vl);
+}
+
+vint32mf2_t
+test___riscv_vle32_tum(vbool64_t mask,vint32mf2_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_tum(mask,merge,base,vl);
+}
+
+vint32m1_t
+test___riscv_vle32_tum(vbool32_t mask,vint32m1_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_tum(mask,merge,base,vl);
+}
+
+vint32m2_t
+test___riscv_vle32_tum(vbool16_t mask,vint32m2_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_tum(mask,merge,base,vl);
+}
+
+vint32m4_t
+test___riscv_vle32_tum(vbool8_t mask,vint32m4_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_tum(mask,merge,base,vl);
+}
+
+vint32m8_t
+test___riscv_vle32_tum(vbool4_t mask,vint32m8_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_tum(mask,merge,base,vl);
+}
+
+vuint32mf2_t
+test___riscv_vle32_tum(vbool64_t mask,vuint32mf2_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_tum(mask,merge,base,vl);
+}
+
+vuint32m1_t
+test___riscv_vle32_tum(vbool32_t mask,vuint32m1_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_tum(mask,merge,base,vl);
+}
+
+vuint32m2_t
+test___riscv_vle32_tum(vbool16_t mask,vuint32m2_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_tum(mask,merge,base,vl);
+}
+
+vuint32m4_t
+test___riscv_vle32_tum(vbool8_t mask,vuint32m4_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_tum(mask,merge,base,vl);
+}
+
+vuint32m8_t
+test___riscv_vle32_tum(vbool4_t mask,vuint32m8_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_tum(mask,merge,base,vl);
+}
+
+vfloat32mf2_t
+test___riscv_vle32_tum(vbool64_t mask,vfloat32mf2_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_tum(mask,merge,base,vl);
+}
+
+vfloat32m1_t
+test___riscv_vle32_tum(vbool32_t mask,vfloat32m1_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_tum(mask,merge,base,vl);
+}
+
+vfloat32m2_t
+test___riscv_vle32_tum(vbool16_t mask,vfloat32m2_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_tum(mask,merge,base,vl);
+}
+
+vfloat32m4_t
+test___riscv_vle32_tum(vbool8_t mask,vfloat32m4_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_tum(mask,merge,base,vl);
+}
+
+vfloat32m8_t
+test___riscv_vle32_tum(vbool4_t mask,vfloat32m8_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_tum(mask,merge,base,vl);
+}
+
+vint64m1_t
+test___riscv_vle64_tum(vbool64_t mask,vint64m1_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_tum(mask,merge,base,vl);
+}
+
+vint64m2_t
+test___riscv_vle64_tum(vbool32_t mask,vint64m2_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_tum(mask,merge,base,vl);
+}
+
+vint64m4_t
+test___riscv_vle64_tum(vbool16_t mask,vint64m4_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_tum(mask,merge,base,vl);
+}
+
+vint64m8_t
+test___riscv_vle64_tum(vbool8_t mask,vint64m8_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_tum(mask,merge,base,vl);
+}
+
+vuint64m1_t
+test___riscv_vle64_tum(vbool64_t mask,vuint64m1_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_tum(mask,merge,base,vl);
+}
+
+vuint64m2_t
+test___riscv_vle64_tum(vbool32_t mask,vuint64m2_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_tum(mask,merge,base,vl);
+}
+
+vuint64m4_t
+test___riscv_vle64_tum(vbool16_t mask,vuint64m4_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_tum(mask,merge,base,vl);
+}
+
+vuint64m8_t
+test___riscv_vle64_tum(vbool8_t mask,vuint64m8_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_tum(mask,merge,base,vl);
+}
+
+vfloat64m1_t
+test___riscv_vle64_tum(vbool64_t mask,vfloat64m1_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_tum(mask,merge,base,vl);
+}
+
+vfloat64m2_t
+test___riscv_vle64_tum(vbool32_t mask,vfloat64m2_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_tum(mask,merge,base,vl);
+}
+
+vfloat64m4_t
+test___riscv_vle64_tum(vbool16_t mask,vfloat64m4_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_tum(mask,merge,base,vl);
+}
+
+vfloat64m8_t
+test___riscv_vle64_tum(vbool8_t mask,vfloat64m8_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_tum(mask,merge,base,vl);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vle_tumu-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vle_tumu-1.C
new file mode 100644
index 0000000..a9a2603
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vle_tumu-1.C
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vle8_tumu(vbool64_t mask,vint8mf8_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_tumu(mask,merge,base,vl);
+}
+
+vint8mf4_t
+test___riscv_vle8_tumu(vbool32_t mask,vint8mf4_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_tumu(mask,merge,base,vl);
+}
+
+vint8mf2_t
+test___riscv_vle8_tumu(vbool16_t mask,vint8mf2_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_tumu(mask,merge,base,vl);
+}
+
+vint8m1_t
+test___riscv_vle8_tumu(vbool8_t mask,vint8m1_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_tumu(mask,merge,base,vl);
+}
+
+vint8m2_t
+test___riscv_vle8_tumu(vbool4_t mask,vint8m2_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_tumu(mask,merge,base,vl);
+}
+
+vint8m4_t
+test___riscv_vle8_tumu(vbool2_t mask,vint8m4_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_tumu(mask,merge,base,vl);
+}
+
+vint8m8_t
+test___riscv_vle8_tumu(vbool1_t mask,vint8m8_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_tumu(mask,merge,base,vl);
+}
+
+vuint8mf8_t
+test___riscv_vle8_tumu(vbool64_t mask,vuint8mf8_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_tumu(mask,merge,base,vl);
+}
+
+vuint8mf4_t
+test___riscv_vle8_tumu(vbool32_t mask,vuint8mf4_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_tumu(mask,merge,base,vl);
+}
+
+vuint8mf2_t
+test___riscv_vle8_tumu(vbool16_t mask,vuint8mf2_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_tumu(mask,merge,base,vl);
+}
+
+vuint8m1_t
+test___riscv_vle8_tumu(vbool8_t mask,vuint8m1_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_tumu(mask,merge,base,vl);
+}
+
+vuint8m2_t
+test___riscv_vle8_tumu(vbool4_t mask,vuint8m2_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_tumu(mask,merge,base,vl);
+}
+
+vuint8m4_t
+test___riscv_vle8_tumu(vbool2_t mask,vuint8m4_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_tumu(mask,merge,base,vl);
+}
+
+vuint8m8_t
+test___riscv_vle8_tumu(vbool1_t mask,vuint8m8_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_tumu(mask,merge,base,vl);
+}
+
+vint16mf4_t
+test___riscv_vle16_tumu(vbool64_t mask,vint16mf4_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_tumu(mask,merge,base,vl);
+}
+
+vint16mf2_t
+test___riscv_vle16_tumu(vbool32_t mask,vint16mf2_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_tumu(mask,merge,base,vl);
+}
+
+vint16m1_t
+test___riscv_vle16_tumu(vbool16_t mask,vint16m1_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_tumu(mask,merge,base,vl);
+}
+
+vint16m2_t
+test___riscv_vle16_tumu(vbool8_t mask,vint16m2_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_tumu(mask,merge,base,vl);
+}
+
+vint16m4_t
+test___riscv_vle16_tumu(vbool4_t mask,vint16m4_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_tumu(mask,merge,base,vl);
+}
+
+vint16m8_t
+test___riscv_vle16_tumu(vbool2_t mask,vint16m8_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_tumu(mask,merge,base,vl);
+}
+
+vuint16mf4_t
+test___riscv_vle16_tumu(vbool64_t mask,vuint16mf4_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_tumu(mask,merge,base,vl);
+}
+
+vuint16mf2_t
+test___riscv_vle16_tumu(vbool32_t mask,vuint16mf2_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_tumu(mask,merge,base,vl);
+}
+
+vuint16m1_t
+test___riscv_vle16_tumu(vbool16_t mask,vuint16m1_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_tumu(mask,merge,base,vl);
+}
+
+vuint16m2_t
+test___riscv_vle16_tumu(vbool8_t mask,vuint16m2_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_tumu(mask,merge,base,vl);
+}
+
+vuint16m4_t
+test___riscv_vle16_tumu(vbool4_t mask,vuint16m4_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_tumu(mask,merge,base,vl);
+}
+
+vuint16m8_t
+test___riscv_vle16_tumu(vbool2_t mask,vuint16m8_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_tumu(mask,merge,base,vl);
+}
+
+vint32mf2_t
+test___riscv_vle32_tumu(vbool64_t mask,vint32mf2_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_tumu(mask,merge,base,vl);
+}
+
+vint32m1_t
+test___riscv_vle32_tumu(vbool32_t mask,vint32m1_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_tumu(mask,merge,base,vl);
+}
+
+vint32m2_t
+test___riscv_vle32_tumu(vbool16_t mask,vint32m2_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_tumu(mask,merge,base,vl);
+}
+
+vint32m4_t
+test___riscv_vle32_tumu(vbool8_t mask,vint32m4_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_tumu(mask,merge,base,vl);
+}
+
+vint32m8_t
+test___riscv_vle32_tumu(vbool4_t mask,vint32m8_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_tumu(mask,merge,base,vl);
+}
+
+vuint32mf2_t
+test___riscv_vle32_tumu(vbool64_t mask,vuint32mf2_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_tumu(mask,merge,base,vl);
+}
+
+vuint32m1_t
+test___riscv_vle32_tumu(vbool32_t mask,vuint32m1_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_tumu(mask,merge,base,vl);
+}
+
+vuint32m2_t
+test___riscv_vle32_tumu(vbool16_t mask,vuint32m2_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_tumu(mask,merge,base,vl);
+}
+
+vuint32m4_t
+test___riscv_vle32_tumu(vbool8_t mask,vuint32m4_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_tumu(mask,merge,base,vl);
+}
+
+vuint32m8_t
+test___riscv_vle32_tumu(vbool4_t mask,vuint32m8_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_tumu(mask,merge,base,vl);
+}
+
+vfloat32mf2_t
+test___riscv_vle32_tumu(vbool64_t mask,vfloat32mf2_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_tumu(mask,merge,base,vl);
+}
+
+vfloat32m1_t
+test___riscv_vle32_tumu(vbool32_t mask,vfloat32m1_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_tumu(mask,merge,base,vl);
+}
+
+vfloat32m2_t
+test___riscv_vle32_tumu(vbool16_t mask,vfloat32m2_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_tumu(mask,merge,base,vl);
+}
+
+vfloat32m4_t
+test___riscv_vle32_tumu(vbool8_t mask,vfloat32m4_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_tumu(mask,merge,base,vl);
+}
+
+vfloat32m8_t
+test___riscv_vle32_tumu(vbool4_t mask,vfloat32m8_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_tumu(mask,merge,base,vl);
+}
+
+vint64m1_t
+test___riscv_vle64_tumu(vbool64_t mask,vint64m1_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_tumu(mask,merge,base,vl);
+}
+
+vint64m2_t
+test___riscv_vle64_tumu(vbool32_t mask,vint64m2_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_tumu(mask,merge,base,vl);
+}
+
+vint64m4_t
+test___riscv_vle64_tumu(vbool16_t mask,vint64m4_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_tumu(mask,merge,base,vl);
+}
+
+vint64m8_t
+test___riscv_vle64_tumu(vbool8_t mask,vint64m8_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_tumu(mask,merge,base,vl);
+}
+
+vuint64m1_t
+test___riscv_vle64_tumu(vbool64_t mask,vuint64m1_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_tumu(mask,merge,base,vl);
+}
+
+vuint64m2_t
+test___riscv_vle64_tumu(vbool32_t mask,vuint64m2_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_tumu(mask,merge,base,vl);
+}
+
+vuint64m4_t
+test___riscv_vle64_tumu(vbool16_t mask,vuint64m4_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_tumu(mask,merge,base,vl);
+}
+
+vuint64m8_t
+test___riscv_vle64_tumu(vbool8_t mask,vuint64m8_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_tumu(mask,merge,base,vl);
+}
+
+vfloat64m1_t
+test___riscv_vle64_tumu(vbool64_t mask,vfloat64m1_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_tumu(mask,merge,base,vl);
+}
+
+vfloat64m2_t
+test___riscv_vle64_tumu(vbool32_t mask,vfloat64m2_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_tumu(mask,merge,base,vl);
+}
+
+vfloat64m4_t
+test___riscv_vle64_tumu(vbool16_t mask,vfloat64m4_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_tumu(mask,merge,base,vl);
+}
+
+vfloat64m8_t
+test___riscv_vle64_tumu(vbool8_t mask,vfloat64m8_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_tumu(mask,merge,base,vl);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*mu\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16-1.C
new file mode 100644
index 0000000..0edea6d
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16-1.C
@@ -0,0 +1,660 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei16(const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei16(const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei16(const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei16(const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei16(const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vloxei16(const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei16(const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei16(const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei16(const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei16(const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei16(const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vloxei16(const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei16(const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei16(const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei16(const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei16(const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei16(const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei16(const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei16(const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei16(const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei16(const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16(const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16(const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16(const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei16(const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei16(const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vloxei16(const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16(const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16(const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei16(const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei16(const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei16(const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vloxei16(const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16(const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei16(const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei16(const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei16(const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei16(const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei16(const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei16(const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei16(const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei16(const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16(const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16(const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16(const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16(const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16(const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16(const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16(const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16(const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16(const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,vl);
+}
+
+
+vint8mf8_t test___riscv_vloxei16(vbool64_t mask,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei16(vbool32_t mask,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei16(vbool16_t mask,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei16(vbool8_t mask,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei16(vbool4_t mask,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vloxei16(vbool2_t mask,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei16(vbool64_t mask,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei16(vbool32_t mask,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei16(vbool16_t mask,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei16(vbool8_t mask,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei16(vbool4_t mask,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vloxei16(vbool2_t mask,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei16(vbool64_t mask,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei16(vbool32_t mask,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei16(vbool16_t mask,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei16(vbool8_t mask,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei16(vbool4_t mask,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei16(vbool64_t mask,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei16(vbool32_t mask,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei16(vbool16_t mask,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei16(vbool8_t mask,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16(vbool64_t mask,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16(vbool32_t mask,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16(vbool16_t mask,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei16(vbool8_t mask,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei16(vbool4_t mask,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vloxei16(vbool2_t mask,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16(vbool64_t mask,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16(vbool32_t mask,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei16(vbool16_t mask,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei16(vbool8_t mask,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei16(vbool4_t mask,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vloxei16(vbool2_t mask,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16(vbool64_t mask,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei16(vbool32_t mask,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei16(vbool16_t mask,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei16(vbool8_t mask,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei16(vbool4_t mask,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei16(vbool64_t mask,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei16(vbool32_t mask,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei16(vbool16_t mask,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei16(vbool8_t mask,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16(vbool64_t mask,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16(vbool32_t mask,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16(vbool16_t mask,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16(vbool8_t mask,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16(vbool4_t mask,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16(vbool64_t mask,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16(vbool32_t mask,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16(vbool16_t mask,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16(vbool8_t mask,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16-2.C
new file mode 100644
index 0000000..26ec06d
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16-2.C
@@ -0,0 +1,660 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei16(const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei16(const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei16(const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei16(const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei16(const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vloxei16(const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei16(const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei16(const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei16(const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei16(const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei16(const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vloxei16(const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei16(const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei16(const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei16(const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei16(const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei16(const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei16(const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei16(const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei16(const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei16(const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16(const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16(const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16(const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei16(const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei16(const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vloxei16(const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16(const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16(const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei16(const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei16(const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei16(const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vloxei16(const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16(const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei16(const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei16(const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei16(const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei16(const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei16(const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei16(const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei16(const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei16(const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16(const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16(const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16(const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16(const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16(const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16(const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16(const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16(const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16(const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,31);
+}
+
+
+vint8mf8_t test___riscv_vloxei16(vbool64_t mask,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei16(vbool32_t mask,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei16(vbool16_t mask,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei16(vbool8_t mask,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei16(vbool4_t mask,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vloxei16(vbool2_t mask,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei16(vbool64_t mask,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei16(vbool32_t mask,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei16(vbool16_t mask,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei16(vbool8_t mask,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei16(vbool4_t mask,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vloxei16(vbool2_t mask,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei16(vbool64_t mask,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei16(vbool32_t mask,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei16(vbool16_t mask,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei16(vbool8_t mask,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei16(vbool4_t mask,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei16(vbool64_t mask,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei16(vbool32_t mask,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei16(vbool16_t mask,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei16(vbool8_t mask,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16(vbool64_t mask,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16(vbool32_t mask,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16(vbool16_t mask,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei16(vbool8_t mask,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei16(vbool4_t mask,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vloxei16(vbool2_t mask,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16(vbool64_t mask,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16(vbool32_t mask,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei16(vbool16_t mask,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei16(vbool8_t mask,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei16(vbool4_t mask,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vloxei16(vbool2_t mask,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16(vbool64_t mask,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei16(vbool32_t mask,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei16(vbool16_t mask,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei16(vbool8_t mask,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei16(vbool4_t mask,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei16(vbool64_t mask,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei16(vbool32_t mask,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei16(vbool16_t mask,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei16(vbool8_t mask,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16(vbool64_t mask,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16(vbool32_t mask,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16(vbool16_t mask,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16(vbool8_t mask,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16(vbool4_t mask,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16(vbool64_t mask,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16(vbool32_t mask,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16(vbool16_t mask,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16(vbool8_t mask,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16-3.C
new file mode 100644
index 0000000..e66a505
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16-3.C
@@ -0,0 +1,660 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei16(const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei16(const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei16(const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei16(const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei16(const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vloxei16(const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei16(const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei16(const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei16(const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei16(const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei16(const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vloxei16(const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei16(const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei16(const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei16(const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei16(const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei16(const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei16(const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei16(const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei16(const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei16(const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16(const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16(const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16(const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei16(const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei16(const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vloxei16(const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16(const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16(const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei16(const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei16(const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei16(const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vloxei16(const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16(const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei16(const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei16(const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei16(const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei16(const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei16(const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei16(const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei16(const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei16(const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16(const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16(const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16(const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16(const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16(const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16(const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16(const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16(const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16(const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(base,bindex,32);
+}
+
+
+vint8mf8_t test___riscv_vloxei16(vbool64_t mask,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei16(vbool32_t mask,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei16(vbool16_t mask,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei16(vbool8_t mask,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei16(vbool4_t mask,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vloxei16(vbool2_t mask,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei16(vbool64_t mask,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei16(vbool32_t mask,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei16(vbool16_t mask,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei16(vbool8_t mask,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei16(vbool4_t mask,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vloxei16(vbool2_t mask,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei16(vbool64_t mask,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei16(vbool32_t mask,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei16(vbool16_t mask,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei16(vbool8_t mask,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei16(vbool4_t mask,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei16(vbool64_t mask,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei16(vbool32_t mask,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei16(vbool16_t mask,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei16(vbool8_t mask,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16(vbool64_t mask,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16(vbool32_t mask,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16(vbool16_t mask,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei16(vbool8_t mask,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei16(vbool4_t mask,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vloxei16(vbool2_t mask,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16(vbool64_t mask,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16(vbool32_t mask,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei16(vbool16_t mask,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei16(vbool8_t mask,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei16(vbool4_t mask,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vloxei16(vbool2_t mask,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16(vbool64_t mask,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei16(vbool32_t mask,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei16(vbool16_t mask,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei16(vbool8_t mask,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei16(vbool4_t mask,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei16(vbool64_t mask,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei16(vbool32_t mask,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei16(vbool16_t mask,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei16(vbool8_t mask,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16(vbool64_t mask,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16(vbool32_t mask,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16(vbool16_t mask,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16(vbool8_t mask,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16(vbool4_t mask,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16(vbool64_t mask,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16(vbool32_t mask,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16(vbool16_t mask,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16(vbool8_t mask,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16(mask,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_mu-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_mu-1.C
new file mode 100644
index 0000000..0a41e0d
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_mu-1.C
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei16_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei16_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei16_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei16_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei16_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vloxei16_mu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei16_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei16_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei16_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei16_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei16_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vloxei16_mu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei16_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei16_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei16_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei16_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei16_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei16_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei16_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei16_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei16_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei16_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei16_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vloxei16_mu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei16_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei16_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei16_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vloxei16_mu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei16_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei16_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei16_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei16_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei16_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei16_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei16_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei16_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_mu-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_mu-2.C
new file mode 100644
index 0000000..16e042e
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_mu-2.C
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei16_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei16_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei16_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei16_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei16_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vloxei16_mu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei16_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei16_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei16_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei16_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei16_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vloxei16_mu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei16_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei16_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei16_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei16_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei16_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei16_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei16_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei16_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei16_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei16_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei16_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vloxei16_mu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei16_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei16_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei16_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vloxei16_mu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei16_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei16_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei16_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei16_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei16_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei16_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei16_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei16_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_mu-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_mu-3.C
new file mode 100644
index 0000000..f54e8bb
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_mu-3.C
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei16_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei16_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei16_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei16_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei16_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vloxei16_mu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei16_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei16_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei16_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei16_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei16_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vloxei16_mu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei16_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei16_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei16_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei16_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei16_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei16_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei16_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei16_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei16_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei16_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei16_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vloxei16_mu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei16_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei16_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei16_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vloxei16_mu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei16_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei16_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei16_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei16_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei16_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei16_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei16_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei16_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_tu-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_tu-1.C
new file mode 100644
index 0000000..3024d8f
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_tu-1.C
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei16_tu(vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei16_tu(vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei16_tu(vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei16_tu(vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei16_tu(vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vloxei16_tu(vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei16_tu(vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei16_tu(vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei16_tu(vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei16_tu(vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei16_tu(vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vloxei16_tu(vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei16_tu(vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei16_tu(vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei16_tu(vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei16_tu(vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei16_tu(vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei16_tu(vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei16_tu(vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei16_tu(vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei16_tu(vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16_tu(vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16_tu(vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16_tu(vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei16_tu(vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei16_tu(vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vloxei16_tu(vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16_tu(vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16_tu(vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei16_tu(vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei16_tu(vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei16_tu(vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vloxei16_tu(vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16_tu(vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei16_tu(vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei16_tu(vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei16_tu(vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei16_tu(vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei16_tu(vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei16_tu(vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei16_tu(vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei16_tu(vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16_tu(vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16_tu(vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16_tu(vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16_tu(vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16_tu(vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16_tu(vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16_tu(vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16_tu(vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16_tu(vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_tu-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_tu-2.C
new file mode 100644
index 0000000..51448ac
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_tu-2.C
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei16_tu(vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei16_tu(vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei16_tu(vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei16_tu(vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei16_tu(vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vloxei16_tu(vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei16_tu(vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei16_tu(vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei16_tu(vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei16_tu(vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei16_tu(vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vloxei16_tu(vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei16_tu(vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei16_tu(vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei16_tu(vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei16_tu(vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei16_tu(vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei16_tu(vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei16_tu(vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei16_tu(vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei16_tu(vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16_tu(vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16_tu(vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16_tu(vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei16_tu(vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei16_tu(vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vloxei16_tu(vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16_tu(vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16_tu(vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei16_tu(vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei16_tu(vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei16_tu(vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vloxei16_tu(vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16_tu(vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei16_tu(vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei16_tu(vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei16_tu(vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei16_tu(vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei16_tu(vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei16_tu(vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei16_tu(vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei16_tu(vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16_tu(vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16_tu(vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16_tu(vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16_tu(vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16_tu(vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16_tu(vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16_tu(vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16_tu(vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16_tu(vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_tu-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_tu-3.C
new file mode 100644
index 0000000..3400737
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_tu-3.C
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei16_tu(vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei16_tu(vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei16_tu(vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei16_tu(vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei16_tu(vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vloxei16_tu(vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei16_tu(vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei16_tu(vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei16_tu(vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei16_tu(vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei16_tu(vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vloxei16_tu(vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei16_tu(vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei16_tu(vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei16_tu(vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei16_tu(vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei16_tu(vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei16_tu(vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei16_tu(vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei16_tu(vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei16_tu(vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16_tu(vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16_tu(vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16_tu(vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei16_tu(vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei16_tu(vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vloxei16_tu(vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16_tu(vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16_tu(vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei16_tu(vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei16_tu(vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei16_tu(vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vloxei16_tu(vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16_tu(vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei16_tu(vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei16_tu(vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei16_tu(vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei16_tu(vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei16_tu(vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei16_tu(vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei16_tu(vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei16_tu(vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16_tu(vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16_tu(vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16_tu(vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16_tu(vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16_tu(vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16_tu(vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16_tu(vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16_tu(vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16_tu(vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tu(merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_tum-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_tum-1.C
new file mode 100644
index 0000000..cb0e175
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_tum-1.C
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei16_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei16_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei16_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei16_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei16_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vloxei16_tum(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei16_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei16_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei16_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei16_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei16_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vloxei16_tum(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei16_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei16_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei16_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei16_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei16_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei16_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei16_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei16_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei16_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei16_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei16_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vloxei16_tum(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei16_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei16_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei16_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vloxei16_tum(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei16_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei16_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei16_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei16_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei16_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei16_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei16_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei16_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_tum-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_tum-2.C
new file mode 100644
index 0000000..0ca2f95
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_tum-2.C
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei16_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei16_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei16_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei16_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei16_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vloxei16_tum(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei16_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei16_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei16_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei16_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei16_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vloxei16_tum(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei16_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei16_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei16_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei16_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei16_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei16_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei16_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei16_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei16_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei16_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei16_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vloxei16_tum(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei16_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei16_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei16_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vloxei16_tum(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei16_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei16_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei16_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei16_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei16_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei16_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei16_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei16_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_tum-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_tum-3.C
new file mode 100644
index 0000000..dddc13b
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_tum-3.C
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei16_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei16_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei16_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei16_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei16_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vloxei16_tum(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei16_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei16_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei16_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei16_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei16_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vloxei16_tum(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei16_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei16_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei16_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei16_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei16_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei16_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei16_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei16_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei16_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei16_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei16_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vloxei16_tum(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei16_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei16_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei16_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vloxei16_tum(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei16_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei16_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei16_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei16_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei16_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei16_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei16_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei16_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_tumu-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_tumu-1.C
new file mode 100644
index 0000000..4b5ee50
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_tumu-1.C
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei16_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei16_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei16_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei16_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei16_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vloxei16_tumu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei16_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei16_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei16_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei16_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei16_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vloxei16_tumu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei16_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei16_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei16_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei16_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei16_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei16_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei16_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei16_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei16_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei16_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei16_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vloxei16_tumu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei16_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei16_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei16_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vloxei16_tumu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei16_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei16_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei16_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei16_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei16_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei16_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei16_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei16_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_tumu-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_tumu-2.C
new file mode 100644
index 0000000..f81107d
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_tumu-2.C
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei16_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei16_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei16_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei16_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei16_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vloxei16_tumu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei16_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei16_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei16_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei16_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei16_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vloxei16_tumu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei16_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei16_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei16_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei16_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei16_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei16_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei16_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei16_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei16_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei16_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei16_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vloxei16_tumu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei16_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei16_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei16_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vloxei16_tumu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei16_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei16_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei16_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei16_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei16_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei16_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei16_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei16_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_tumu-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_tumu-3.C
new file mode 100644
index 0000000..0c764e6
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei16_tumu-3.C
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei16_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei16_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei16_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei16_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei16_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vloxei16_tumu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei16_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei16_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei16_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei16_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei16_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vloxei16_tumu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei16_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei16_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei16_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei16_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei16_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei16_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei16_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei16_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei16_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei16_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei16_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vloxei16_tumu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei16_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei16_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei16_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vloxei16_tumu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei16_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei16_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei16_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei16_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei16_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei16_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei16_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei16_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32-1.C
new file mode 100644
index 0000000..10060e7
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32-1.C
@@ -0,0 +1,608 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei32(const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei32(const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei32(const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei32(const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei32(const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei32(const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei32(const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei32(const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei32(const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei32(const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei32(const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei32(const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei32(const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei32(const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei32(const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei32(const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei32(const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei32(const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei32(const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32(const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32(const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32(const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei32(const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei32(const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32(const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32(const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei32(const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei32(const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei32(const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32(const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei32(const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei32(const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei32(const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei32(const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei32(const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei32(const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei32(const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei32(const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32(const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32(const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32(const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32(const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32(const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32(const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32(const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32(const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32(const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,vl);
+}
+
+
+vint8mf8_t test___riscv_vloxei32(vbool64_t mask,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei32(vbool32_t mask,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei32(vbool16_t mask,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei32(vbool8_t mask,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei32(vbool4_t mask,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei32(vbool64_t mask,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei32(vbool32_t mask,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei32(vbool16_t mask,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei32(vbool8_t mask,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei32(vbool4_t mask,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei32(vbool64_t mask,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei32(vbool32_t mask,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei32(vbool16_t mask,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei32(vbool8_t mask,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei32(vbool4_t mask,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei32(vbool64_t mask,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei32(vbool32_t mask,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei32(vbool16_t mask,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei32(vbool8_t mask,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32(vbool64_t mask,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32(vbool32_t mask,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32(vbool16_t mask,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei32(vbool8_t mask,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei32(vbool4_t mask,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32(vbool64_t mask,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32(vbool32_t mask,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei32(vbool16_t mask,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei32(vbool8_t mask,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei32(vbool4_t mask,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32(vbool64_t mask,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei32(vbool32_t mask,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei32(vbool16_t mask,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei32(vbool8_t mask,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei32(vbool4_t mask,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei32(vbool64_t mask,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei32(vbool32_t mask,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei32(vbool16_t mask,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei32(vbool8_t mask,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32(vbool64_t mask,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32(vbool32_t mask,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32(vbool16_t mask,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32(vbool8_t mask,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32(vbool4_t mask,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32(vbool64_t mask,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32(vbool32_t mask,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32(vbool16_t mask,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32(vbool8_t mask,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32-2.C
new file mode 100644
index 0000000..1d09746
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32-2.C
@@ -0,0 +1,608 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei32(const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei32(const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei32(const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei32(const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei32(const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei32(const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei32(const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei32(const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei32(const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei32(const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei32(const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei32(const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei32(const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei32(const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei32(const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei32(const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei32(const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei32(const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei32(const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32(const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32(const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32(const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei32(const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei32(const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32(const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32(const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei32(const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei32(const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei32(const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32(const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei32(const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei32(const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei32(const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei32(const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei32(const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei32(const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei32(const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei32(const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32(const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32(const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32(const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32(const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32(const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32(const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32(const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32(const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32(const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,31);
+}
+
+
+vint8mf8_t test___riscv_vloxei32(vbool64_t mask,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei32(vbool32_t mask,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei32(vbool16_t mask,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei32(vbool8_t mask,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei32(vbool4_t mask,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei32(vbool64_t mask,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei32(vbool32_t mask,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei32(vbool16_t mask,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei32(vbool8_t mask,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei32(vbool4_t mask,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei32(vbool64_t mask,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei32(vbool32_t mask,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei32(vbool16_t mask,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei32(vbool8_t mask,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei32(vbool4_t mask,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei32(vbool64_t mask,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei32(vbool32_t mask,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei32(vbool16_t mask,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei32(vbool8_t mask,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32(vbool64_t mask,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32(vbool32_t mask,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32(vbool16_t mask,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei32(vbool8_t mask,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei32(vbool4_t mask,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32(vbool64_t mask,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32(vbool32_t mask,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei32(vbool16_t mask,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei32(vbool8_t mask,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei32(vbool4_t mask,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32(vbool64_t mask,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei32(vbool32_t mask,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei32(vbool16_t mask,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei32(vbool8_t mask,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei32(vbool4_t mask,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei32(vbool64_t mask,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei32(vbool32_t mask,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei32(vbool16_t mask,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei32(vbool8_t mask,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32(vbool64_t mask,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32(vbool32_t mask,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32(vbool16_t mask,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32(vbool8_t mask,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32(vbool4_t mask,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32(vbool64_t mask,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32(vbool32_t mask,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32(vbool16_t mask,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32(vbool8_t mask,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32-3.C
new file mode 100644
index 0000000..68f2ec3
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32-3.C
@@ -0,0 +1,608 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei32(const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei32(const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei32(const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei32(const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei32(const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei32(const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei32(const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei32(const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei32(const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei32(const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei32(const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei32(const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei32(const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei32(const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei32(const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei32(const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei32(const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei32(const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei32(const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32(const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32(const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32(const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei32(const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei32(const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32(const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32(const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei32(const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei32(const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei32(const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32(const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei32(const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei32(const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei32(const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei32(const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei32(const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei32(const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei32(const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei32(const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32(const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32(const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32(const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32(const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32(const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32(const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32(const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32(const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32(const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(base,bindex,32);
+}
+
+
+vint8mf8_t test___riscv_vloxei32(vbool64_t mask,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei32(vbool32_t mask,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei32(vbool16_t mask,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei32(vbool8_t mask,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei32(vbool4_t mask,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei32(vbool64_t mask,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei32(vbool32_t mask,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei32(vbool16_t mask,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei32(vbool8_t mask,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei32(vbool4_t mask,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei32(vbool64_t mask,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei32(vbool32_t mask,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei32(vbool16_t mask,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei32(vbool8_t mask,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei32(vbool4_t mask,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei32(vbool64_t mask,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei32(vbool32_t mask,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei32(vbool16_t mask,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei32(vbool8_t mask,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32(vbool64_t mask,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32(vbool32_t mask,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32(vbool16_t mask,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei32(vbool8_t mask,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei32(vbool4_t mask,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32(vbool64_t mask,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32(vbool32_t mask,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei32(vbool16_t mask,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei32(vbool8_t mask,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei32(vbool4_t mask,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32(vbool64_t mask,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei32(vbool32_t mask,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei32(vbool16_t mask,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei32(vbool8_t mask,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei32(vbool4_t mask,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei32(vbool64_t mask,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei32(vbool32_t mask,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei32(vbool16_t mask,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei32(vbool8_t mask,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32(vbool64_t mask,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32(vbool32_t mask,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32(vbool16_t mask,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32(vbool8_t mask,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32(vbool4_t mask,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32(vbool64_t mask,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32(vbool32_t mask,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32(vbool16_t mask,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32(vbool8_t mask,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32(mask,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_mu-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_mu-1.C
new file mode 100644
index 0000000..9187ad5
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_mu-1.C
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei32_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei32_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei32_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei32_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei32_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei32_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei32_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei32_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei32_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei32_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei32_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei32_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei32_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei32_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei32_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei32_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei32_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei32_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei32_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei32_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei32_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei32_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei32_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei32_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei32_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei32_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei32_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei32_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei32_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei32_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei32_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei32_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_mu-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_mu-2.C
new file mode 100644
index 0000000..ac60097
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_mu-2.C
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei32_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei32_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei32_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei32_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei32_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei32_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei32_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei32_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei32_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei32_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei32_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei32_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei32_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei32_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei32_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei32_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei32_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei32_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei32_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei32_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei32_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei32_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei32_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei32_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei32_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei32_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei32_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei32_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei32_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei32_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei32_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei32_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_mu-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_mu-3.C
new file mode 100644
index 0000000..c962aa7
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_mu-3.C
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei32_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei32_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei32_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei32_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei32_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei32_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei32_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei32_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei32_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei32_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei32_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei32_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei32_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei32_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei32_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei32_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei32_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei32_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei32_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei32_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei32_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei32_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei32_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei32_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei32_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei32_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei32_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei32_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei32_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei32_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei32_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei32_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_tu-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_tu-1.C
new file mode 100644
index 0000000..98a3c15
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_tu-1.C
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei32_tu(vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei32_tu(vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei32_tu(vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei32_tu(vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei32_tu(vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei32_tu(vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei32_tu(vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei32_tu(vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei32_tu(vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei32_tu(vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei32_tu(vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei32_tu(vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei32_tu(vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei32_tu(vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei32_tu(vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei32_tu(vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei32_tu(vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei32_tu(vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei32_tu(vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32_tu(vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32_tu(vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32_tu(vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei32_tu(vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei32_tu(vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32_tu(vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32_tu(vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei32_tu(vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei32_tu(vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei32_tu(vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32_tu(vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei32_tu(vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei32_tu(vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei32_tu(vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei32_tu(vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei32_tu(vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei32_tu(vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei32_tu(vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei32_tu(vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32_tu(vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32_tu(vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32_tu(vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32_tu(vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32_tu(vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32_tu(vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32_tu(vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32_tu(vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32_tu(vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_tu-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_tu-2.C
new file mode 100644
index 0000000..182f881
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_tu-2.C
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei32_tu(vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei32_tu(vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei32_tu(vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei32_tu(vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei32_tu(vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei32_tu(vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei32_tu(vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei32_tu(vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei32_tu(vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei32_tu(vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei32_tu(vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei32_tu(vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei32_tu(vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei32_tu(vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei32_tu(vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei32_tu(vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei32_tu(vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei32_tu(vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei32_tu(vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32_tu(vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32_tu(vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32_tu(vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei32_tu(vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei32_tu(vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32_tu(vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32_tu(vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei32_tu(vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei32_tu(vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei32_tu(vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32_tu(vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei32_tu(vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei32_tu(vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei32_tu(vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei32_tu(vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei32_tu(vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei32_tu(vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei32_tu(vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei32_tu(vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32_tu(vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32_tu(vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32_tu(vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32_tu(vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32_tu(vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32_tu(vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32_tu(vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32_tu(vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32_tu(vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_tu-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_tu-3.C
new file mode 100644
index 0000000..6063d13
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_tu-3.C
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei32_tu(vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei32_tu(vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei32_tu(vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei32_tu(vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei32_tu(vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei32_tu(vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei32_tu(vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei32_tu(vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei32_tu(vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei32_tu(vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei32_tu(vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei32_tu(vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei32_tu(vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei32_tu(vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei32_tu(vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei32_tu(vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei32_tu(vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei32_tu(vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei32_tu(vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32_tu(vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32_tu(vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32_tu(vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei32_tu(vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei32_tu(vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32_tu(vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32_tu(vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei32_tu(vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei32_tu(vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei32_tu(vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32_tu(vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei32_tu(vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei32_tu(vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei32_tu(vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei32_tu(vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei32_tu(vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei32_tu(vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei32_tu(vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei32_tu(vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32_tu(vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32_tu(vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32_tu(vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32_tu(vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32_tu(vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32_tu(vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32_tu(vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32_tu(vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32_tu(vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tu(merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_tum-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_tum-1.C
new file mode 100644
index 0000000..e77fd83
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_tum-1.C
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei32_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei32_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei32_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei32_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei32_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei32_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei32_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei32_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei32_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei32_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei32_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei32_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei32_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei32_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei32_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei32_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei32_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei32_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei32_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei32_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei32_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei32_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei32_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei32_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei32_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei32_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei32_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei32_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei32_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei32_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei32_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei32_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_tum-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_tum-2.C
new file mode 100644
index 0000000..774559d
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_tum-2.C
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei32_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei32_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei32_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei32_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei32_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei32_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei32_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei32_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei32_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei32_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei32_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei32_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei32_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei32_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei32_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei32_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei32_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei32_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei32_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei32_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei32_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei32_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei32_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei32_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei32_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei32_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei32_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei32_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei32_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei32_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei32_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei32_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_tum-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_tum-3.C
new file mode 100644
index 0000000..103d612
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_tum-3.C
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei32_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei32_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei32_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei32_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei32_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei32_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei32_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei32_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei32_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei32_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei32_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei32_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei32_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei32_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei32_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei32_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei32_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei32_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei32_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei32_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei32_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei32_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei32_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei32_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei32_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei32_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei32_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei32_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei32_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei32_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei32_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei32_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_tumu-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_tumu-1.C
new file mode 100644
index 0000000..b232184
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_tumu-1.C
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei32_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei32_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei32_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei32_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei32_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei32_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei32_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei32_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei32_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei32_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei32_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei32_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei32_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei32_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei32_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei32_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei32_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei32_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei32_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei32_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei32_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei32_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei32_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei32_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei32_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei32_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei32_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei32_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei32_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei32_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei32_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei32_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_tumu-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_tumu-2.C
new file mode 100644
index 0000000..a8a0116
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_tumu-2.C
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei32_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei32_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei32_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei32_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei32_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei32_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei32_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei32_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei32_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei32_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei32_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei32_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei32_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei32_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei32_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei32_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei32_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei32_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei32_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei32_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei32_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei32_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei32_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei32_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei32_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei32_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei32_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei32_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei32_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei32_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei32_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei32_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_tumu-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_tumu-3.C
new file mode 100644
index 0000000..de92c2c
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei32_tumu-3.C
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei32_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei32_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei32_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei32_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei32_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei32_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei32_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei32_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei32_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei32_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei32_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei32_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei32_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei32_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei32_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei32_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei32_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei32_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei32_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei32_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei32_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei32_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei32_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei32_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei32_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei32_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei32_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei32_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei32_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei32_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei32_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei32_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64-1.C
new file mode 100644
index 0000000..303a8e1
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64-1.C
@@ -0,0 +1,518 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei64(const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei64(const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei64(const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei64(const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei64(const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei64(const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei64(const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei64(const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei64(const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei64(const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei64(const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei64(const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei64(const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei64(const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei64(const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei64(const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64(const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64(const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64(const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei64(const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64(const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64(const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei64(const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei64(const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64(const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei64(const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei64(const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei64(const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei64(const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei64(const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei64(const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei64(const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64(const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64(const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64(const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64(const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64(const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64(const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64(const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64(const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,vl);
+}
+
+
+vint8mf8_t test___riscv_vloxei64(vbool64_t mask,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei64(vbool32_t mask,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei64(vbool16_t mask,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei64(vbool8_t mask,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei64(vbool64_t mask,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei64(vbool32_t mask,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei64(vbool16_t mask,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei64(vbool8_t mask,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei64(vbool64_t mask,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei64(vbool32_t mask,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei64(vbool16_t mask,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei64(vbool8_t mask,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei64(vbool64_t mask,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei64(vbool32_t mask,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei64(vbool16_t mask,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei64(vbool8_t mask,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64(vbool64_t mask,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64(vbool32_t mask,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64(vbool16_t mask,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei64(vbool8_t mask,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64(vbool64_t mask,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64(vbool32_t mask,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei64(vbool16_t mask,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei64(vbool8_t mask,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64(vbool64_t mask,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei64(vbool32_t mask,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei64(vbool16_t mask,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei64(vbool8_t mask,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei64(vbool64_t mask,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei64(vbool32_t mask,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei64(vbool16_t mask,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei64(vbool8_t mask,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64(vbool64_t mask,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64(vbool32_t mask,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64(vbool16_t mask,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64(vbool8_t mask,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64(vbool64_t mask,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64(vbool32_t mask,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64(vbool16_t mask,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64(vbool8_t mask,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64-2.C
new file mode 100644
index 0000000..d70087e
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64-2.C
@@ -0,0 +1,518 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei64(const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei64(const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei64(const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei64(const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei64(const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei64(const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei64(const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei64(const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei64(const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei64(const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei64(const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei64(const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei64(const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei64(const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei64(const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei64(const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64(const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64(const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64(const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei64(const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64(const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64(const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei64(const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei64(const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64(const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei64(const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei64(const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei64(const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei64(const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei64(const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei64(const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei64(const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64(const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64(const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64(const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64(const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64(const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64(const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64(const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64(const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,31);
+}
+
+
+vint8mf8_t test___riscv_vloxei64(vbool64_t mask,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei64(vbool32_t mask,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei64(vbool16_t mask,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei64(vbool8_t mask,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei64(vbool64_t mask,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei64(vbool32_t mask,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei64(vbool16_t mask,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei64(vbool8_t mask,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei64(vbool64_t mask,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei64(vbool32_t mask,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei64(vbool16_t mask,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei64(vbool8_t mask,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei64(vbool64_t mask,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei64(vbool32_t mask,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei64(vbool16_t mask,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei64(vbool8_t mask,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64(vbool64_t mask,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64(vbool32_t mask,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64(vbool16_t mask,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei64(vbool8_t mask,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64(vbool64_t mask,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64(vbool32_t mask,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei64(vbool16_t mask,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei64(vbool8_t mask,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64(vbool64_t mask,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei64(vbool32_t mask,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei64(vbool16_t mask,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei64(vbool8_t mask,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei64(vbool64_t mask,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei64(vbool32_t mask,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei64(vbool16_t mask,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei64(vbool8_t mask,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64(vbool64_t mask,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64(vbool32_t mask,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64(vbool16_t mask,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64(vbool8_t mask,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64(vbool64_t mask,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64(vbool32_t mask,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64(vbool16_t mask,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64(vbool8_t mask,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64-3.C
new file mode 100644
index 0000000..a239fcc
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64-3.C
@@ -0,0 +1,518 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei64(const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei64(const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei64(const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei64(const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei64(const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei64(const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei64(const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei64(const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei64(const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei64(const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei64(const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei64(const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei64(const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei64(const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei64(const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei64(const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64(const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64(const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64(const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei64(const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64(const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64(const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei64(const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei64(const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64(const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei64(const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei64(const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei64(const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei64(const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei64(const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei64(const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei64(const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64(const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64(const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64(const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64(const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64(const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64(const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64(const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64(const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(base,bindex,32);
+}
+
+
+vint8mf8_t test___riscv_vloxei64(vbool64_t mask,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei64(vbool32_t mask,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei64(vbool16_t mask,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei64(vbool8_t mask,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei64(vbool64_t mask,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei64(vbool32_t mask,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei64(vbool16_t mask,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei64(vbool8_t mask,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei64(vbool64_t mask,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei64(vbool32_t mask,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei64(vbool16_t mask,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei64(vbool8_t mask,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei64(vbool64_t mask,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei64(vbool32_t mask,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei64(vbool16_t mask,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei64(vbool8_t mask,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64(vbool64_t mask,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64(vbool32_t mask,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64(vbool16_t mask,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei64(vbool8_t mask,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64(vbool64_t mask,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64(vbool32_t mask,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei64(vbool16_t mask,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei64(vbool8_t mask,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64(vbool64_t mask,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei64(vbool32_t mask,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei64(vbool16_t mask,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei64(vbool8_t mask,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei64(vbool64_t mask,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei64(vbool32_t mask,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei64(vbool16_t mask,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei64(vbool8_t mask,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64(vbool64_t mask,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64(vbool32_t mask,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64(vbool16_t mask,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64(vbool8_t mask,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64(vbool64_t mask,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64(vbool32_t mask,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64(vbool16_t mask,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64(vbool8_t mask,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64(mask,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_mu-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_mu-1.C
new file mode 100644
index 0000000..445cfc1
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_mu-1.C
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei64_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei64_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei64_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei64_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei64_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei64_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei64_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei64_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei64_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei64_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei64_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei64_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei64_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei64_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei64_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei64_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei64_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei64_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei64_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei64_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei64_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei64_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei64_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei64_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei64_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei64_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_mu-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_mu-2.C
new file mode 100644
index 0000000..a6146a0
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_mu-2.C
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei64_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei64_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei64_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei64_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei64_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei64_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei64_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei64_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei64_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei64_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei64_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei64_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei64_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei64_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei64_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei64_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei64_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei64_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei64_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei64_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei64_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei64_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei64_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei64_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei64_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei64_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_mu-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_mu-3.C
new file mode 100644
index 0000000..503a07f
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_mu-3.C
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei64_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei64_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei64_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei64_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei64_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei64_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei64_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei64_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei64_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei64_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei64_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei64_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei64_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei64_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei64_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei64_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei64_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei64_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei64_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei64_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei64_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei64_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei64_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei64_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei64_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei64_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_tu-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_tu-1.C
new file mode 100644
index 0000000..089fa9e
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_tu-1.C
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei64_tu(vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei64_tu(vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei64_tu(vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei64_tu(vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei64_tu(vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei64_tu(vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei64_tu(vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei64_tu(vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei64_tu(vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei64_tu(vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei64_tu(vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei64_tu(vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei64_tu(vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei64_tu(vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei64_tu(vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei64_tu(vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64_tu(vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64_tu(vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64_tu(vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei64_tu(vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64_tu(vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64_tu(vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei64_tu(vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei64_tu(vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64_tu(vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei64_tu(vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei64_tu(vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei64_tu(vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei64_tu(vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei64_tu(vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei64_tu(vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei64_tu(vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64_tu(vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64_tu(vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64_tu(vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64_tu(vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64_tu(vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64_tu(vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64_tu(vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64_tu(vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_tu-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_tu-2.C
new file mode 100644
index 0000000..e8eddbe
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_tu-2.C
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei64_tu(vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei64_tu(vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei64_tu(vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei64_tu(vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei64_tu(vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei64_tu(vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei64_tu(vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei64_tu(vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei64_tu(vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei64_tu(vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei64_tu(vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei64_tu(vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei64_tu(vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei64_tu(vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei64_tu(vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei64_tu(vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64_tu(vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64_tu(vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64_tu(vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei64_tu(vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64_tu(vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64_tu(vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei64_tu(vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei64_tu(vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64_tu(vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei64_tu(vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei64_tu(vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei64_tu(vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei64_tu(vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei64_tu(vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei64_tu(vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei64_tu(vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64_tu(vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64_tu(vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64_tu(vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64_tu(vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64_tu(vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64_tu(vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64_tu(vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64_tu(vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_tu-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_tu-3.C
new file mode 100644
index 0000000..855fbfa
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_tu-3.C
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei64_tu(vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei64_tu(vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei64_tu(vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei64_tu(vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei64_tu(vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei64_tu(vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei64_tu(vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei64_tu(vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei64_tu(vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei64_tu(vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei64_tu(vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei64_tu(vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei64_tu(vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei64_tu(vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei64_tu(vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei64_tu(vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64_tu(vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64_tu(vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64_tu(vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei64_tu(vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64_tu(vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64_tu(vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei64_tu(vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei64_tu(vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64_tu(vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei64_tu(vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei64_tu(vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei64_tu(vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei64_tu(vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei64_tu(vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei64_tu(vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei64_tu(vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64_tu(vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64_tu(vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64_tu(vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64_tu(vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64_tu(vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64_tu(vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64_tu(vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64_tu(vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tu(merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_tum-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_tum-1.C
new file mode 100644
index 0000000..323e4d4
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_tum-1.C
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei64_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei64_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei64_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei64_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei64_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei64_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei64_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei64_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei64_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei64_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei64_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei64_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei64_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei64_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei64_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei64_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei64_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei64_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei64_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei64_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei64_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei64_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei64_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei64_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei64_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei64_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_tum-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_tum-2.C
new file mode 100644
index 0000000..13c17d7
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_tum-2.C
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei64_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei64_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei64_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei64_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei64_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei64_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei64_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei64_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei64_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei64_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei64_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei64_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei64_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei64_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei64_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei64_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei64_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei64_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei64_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei64_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei64_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei64_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei64_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei64_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei64_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei64_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_tum-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_tum-3.C
new file mode 100644
index 0000000..ed2d5e4
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_tum-3.C
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei64_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei64_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei64_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei64_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei64_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei64_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei64_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei64_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei64_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei64_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei64_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei64_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei64_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei64_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei64_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei64_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei64_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei64_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei64_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei64_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei64_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei64_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei64_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei64_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei64_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei64_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_tumu-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_tumu-1.C
new file mode 100644
index 0000000..5f34be5
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_tumu-1.C
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei64_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei64_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei64_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei64_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei64_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei64_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei64_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei64_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei64_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei64_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei64_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei64_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei64_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei64_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei64_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei64_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei64_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei64_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei64_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei64_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei64_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei64_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei64_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei64_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei64_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei64_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_tumu-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_tumu-2.C
new file mode 100644
index 0000000..85bbb3b
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_tumu-2.C
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei64_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei64_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei64_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei64_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei64_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei64_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei64_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei64_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei64_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei64_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei64_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei64_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei64_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei64_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei64_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei64_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei64_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei64_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei64_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei64_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei64_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei64_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei64_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei64_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei64_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei64_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_tumu-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_tumu-3.C
new file mode 100644
index 0000000..057af5a
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei64_tumu-3.C
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei64_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei64_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei64_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei64_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei64_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei64_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei64_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei64_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei64_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei64_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei64_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei64_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei64_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei64_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei64_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei64_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei64_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei64_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei64_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei64_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei64_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei64_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei64_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei64_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei64_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei64_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8-1.C
new file mode 100644
index 0000000..197f1fd
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8-1.C
@@ -0,0 +1,686 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei8(const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei8(const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei8(const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei8(const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei8(const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vloxei8(const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vint8m8_t test___riscv_vloxei8(const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei8(const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei8(const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei8(const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei8(const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei8(const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vloxei8(const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei8(const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei8(const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei8(const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei8(const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei8(const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei8(const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei8(const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei8(const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei8(const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8(const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8(const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8(const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei8(const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei8(const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vloxei8(const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vuint8m8_t test___riscv_vloxei8(const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8(const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8(const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei8(const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei8(const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei8(const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vloxei8(const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8(const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei8(const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei8(const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei8(const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei8(const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei8(const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei8(const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei8(const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei8(const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8(const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8(const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8(const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8(const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8(const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8(const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8(const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8(const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8(const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,vl);
+}
+
+
+vint8mf8_t test___riscv_vloxei8(vbool64_t mask,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei8(vbool32_t mask,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei8(vbool16_t mask,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei8(vbool8_t mask,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei8(vbool4_t mask,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vloxei8(vbool2_t mask,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vint8m8_t test___riscv_vloxei8(vbool1_t mask,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei8(vbool64_t mask,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei8(vbool32_t mask,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei8(vbool16_t mask,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei8(vbool8_t mask,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei8(vbool4_t mask,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vloxei8(vbool2_t mask,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei8(vbool64_t mask,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei8(vbool32_t mask,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei8(vbool16_t mask,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei8(vbool8_t mask,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei8(vbool4_t mask,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei8(vbool64_t mask,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei8(vbool32_t mask,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei8(vbool16_t mask,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei8(vbool8_t mask,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8(vbool64_t mask,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8(vbool32_t mask,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8(vbool16_t mask,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei8(vbool8_t mask,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei8(vbool4_t mask,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vloxei8(vbool2_t mask,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vuint8m8_t test___riscv_vloxei8(vbool1_t mask,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8(vbool64_t mask,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8(vbool32_t mask,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei8(vbool16_t mask,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei8(vbool8_t mask,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei8(vbool4_t mask,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vloxei8(vbool2_t mask,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8(vbool64_t mask,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei8(vbool32_t mask,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei8(vbool16_t mask,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei8(vbool8_t mask,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei8(vbool4_t mask,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei8(vbool64_t mask,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei8(vbool32_t mask,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei8(vbool16_t mask,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei8(vbool8_t mask,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8(vbool64_t mask,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8(vbool32_t mask,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8(vbool16_t mask,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8(vbool8_t mask,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8(vbool4_t mask,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8(vbool64_t mask,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8(vbool32_t mask,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8(vbool16_t mask,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8(vbool8_t mask,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8-2.C
new file mode 100644
index 0000000..c06e591
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8-2.C
@@ -0,0 +1,686 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei8(const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei8(const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei8(const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei8(const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei8(const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vloxei8(const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vint8m8_t test___riscv_vloxei8(const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei8(const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei8(const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei8(const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei8(const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei8(const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vloxei8(const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei8(const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei8(const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei8(const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei8(const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei8(const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei8(const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei8(const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei8(const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei8(const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8(const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8(const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8(const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei8(const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei8(const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vloxei8(const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vuint8m8_t test___riscv_vloxei8(const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8(const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8(const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei8(const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei8(const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei8(const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vloxei8(const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8(const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei8(const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei8(const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei8(const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei8(const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei8(const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei8(const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei8(const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei8(const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8(const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8(const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8(const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8(const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8(const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8(const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8(const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8(const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8(const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,31);
+}
+
+
+vint8mf8_t test___riscv_vloxei8(vbool64_t mask,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei8(vbool32_t mask,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei8(vbool16_t mask,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei8(vbool8_t mask,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei8(vbool4_t mask,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vloxei8(vbool2_t mask,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vint8m8_t test___riscv_vloxei8(vbool1_t mask,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei8(vbool64_t mask,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei8(vbool32_t mask,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei8(vbool16_t mask,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei8(vbool8_t mask,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei8(vbool4_t mask,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vloxei8(vbool2_t mask,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei8(vbool64_t mask,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei8(vbool32_t mask,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei8(vbool16_t mask,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei8(vbool8_t mask,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei8(vbool4_t mask,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei8(vbool64_t mask,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei8(vbool32_t mask,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei8(vbool16_t mask,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei8(vbool8_t mask,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8(vbool64_t mask,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8(vbool32_t mask,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8(vbool16_t mask,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei8(vbool8_t mask,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei8(vbool4_t mask,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vloxei8(vbool2_t mask,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vuint8m8_t test___riscv_vloxei8(vbool1_t mask,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8(vbool64_t mask,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8(vbool32_t mask,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei8(vbool16_t mask,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei8(vbool8_t mask,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei8(vbool4_t mask,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vloxei8(vbool2_t mask,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8(vbool64_t mask,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei8(vbool32_t mask,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei8(vbool16_t mask,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei8(vbool8_t mask,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei8(vbool4_t mask,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei8(vbool64_t mask,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei8(vbool32_t mask,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei8(vbool16_t mask,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei8(vbool8_t mask,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8(vbool64_t mask,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8(vbool32_t mask,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8(vbool16_t mask,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8(vbool8_t mask,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8(vbool4_t mask,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8(vbool64_t mask,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8(vbool32_t mask,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8(vbool16_t mask,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8(vbool8_t mask,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8-3.C
new file mode 100644
index 0000000..f02debc
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8-3.C
@@ -0,0 +1,686 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei8(const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei8(const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei8(const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei8(const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei8(const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vloxei8(const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vint8m8_t test___riscv_vloxei8(const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei8(const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei8(const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei8(const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei8(const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei8(const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vloxei8(const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei8(const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei8(const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei8(const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei8(const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei8(const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei8(const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei8(const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei8(const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei8(const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8(const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8(const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8(const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei8(const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei8(const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vloxei8(const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vuint8m8_t test___riscv_vloxei8(const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8(const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8(const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei8(const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei8(const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei8(const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vloxei8(const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8(const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei8(const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei8(const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei8(const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei8(const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei8(const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei8(const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei8(const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei8(const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8(const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8(const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8(const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8(const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8(const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8(const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8(const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8(const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8(const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(base,bindex,32);
+}
+
+
+vint8mf8_t test___riscv_vloxei8(vbool64_t mask,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei8(vbool32_t mask,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei8(vbool16_t mask,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei8(vbool8_t mask,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei8(vbool4_t mask,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vloxei8(vbool2_t mask,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vint8m8_t test___riscv_vloxei8(vbool1_t mask,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei8(vbool64_t mask,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei8(vbool32_t mask,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei8(vbool16_t mask,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei8(vbool8_t mask,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei8(vbool4_t mask,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vloxei8(vbool2_t mask,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei8(vbool64_t mask,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei8(vbool32_t mask,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei8(vbool16_t mask,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei8(vbool8_t mask,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei8(vbool4_t mask,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei8(vbool64_t mask,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei8(vbool32_t mask,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei8(vbool16_t mask,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei8(vbool8_t mask,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8(vbool64_t mask,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8(vbool32_t mask,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8(vbool16_t mask,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei8(vbool8_t mask,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei8(vbool4_t mask,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vloxei8(vbool2_t mask,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vuint8m8_t test___riscv_vloxei8(vbool1_t mask,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8(vbool64_t mask,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8(vbool32_t mask,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei8(vbool16_t mask,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei8(vbool8_t mask,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei8(vbool4_t mask,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vloxei8(vbool2_t mask,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8(vbool64_t mask,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei8(vbool32_t mask,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei8(vbool16_t mask,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei8(vbool8_t mask,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei8(vbool4_t mask,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei8(vbool64_t mask,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei8(vbool32_t mask,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei8(vbool16_t mask,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei8(vbool8_t mask,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8(vbool64_t mask,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8(vbool32_t mask,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8(vbool16_t mask,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8(vbool8_t mask,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8(vbool4_t mask,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8(vbool64_t mask,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8(vbool32_t mask,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8(vbool16_t mask,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8(vbool8_t mask,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8(mask,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_mu-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_mu-1.C
new file mode 100644
index 0000000..de18bf9
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_mu-1.C
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei8_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei8_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei8_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei8_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei8_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vloxei8_mu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m8_t test___riscv_vloxei8_mu(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei8_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei8_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei8_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei8_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei8_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vloxei8_mu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei8_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei8_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei8_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei8_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei8_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei8_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei8_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei8_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei8_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei8_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei8_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vloxei8_mu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m8_t test___riscv_vloxei8_mu(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei8_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei8_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei8_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vloxei8_mu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei8_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei8_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei8_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei8_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei8_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei8_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei8_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei8_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_mu-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_mu-2.C
new file mode 100644
index 0000000..2433a60
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_mu-2.C
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei8_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei8_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei8_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei8_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei8_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vloxei8_mu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m8_t test___riscv_vloxei8_mu(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei8_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei8_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei8_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei8_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei8_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vloxei8_mu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei8_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei8_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei8_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei8_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei8_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei8_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei8_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei8_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei8_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei8_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei8_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vloxei8_mu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m8_t test___riscv_vloxei8_mu(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei8_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei8_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei8_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vloxei8_mu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei8_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei8_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei8_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei8_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei8_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei8_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei8_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei8_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_mu-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_mu-3.C
new file mode 100644
index 0000000..8a14e28
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_mu-3.C
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei8_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei8_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei8_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei8_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei8_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vloxei8_mu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m8_t test___riscv_vloxei8_mu(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei8_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei8_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei8_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei8_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei8_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vloxei8_mu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei8_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei8_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei8_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei8_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei8_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei8_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei8_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei8_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei8_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei8_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei8_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vloxei8_mu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m8_t test___riscv_vloxei8_mu(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei8_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei8_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei8_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vloxei8_mu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei8_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei8_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei8_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei8_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei8_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei8_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei8_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei8_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_tu-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_tu-1.C
new file mode 100644
index 0000000..933d49e
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_tu-1.C
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei8_tu(vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei8_tu(vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei8_tu(vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei8_tu(vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei8_tu(vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vloxei8_tu(vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint8m8_t test___riscv_vloxei8_tu(vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei8_tu(vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei8_tu(vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei8_tu(vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei8_tu(vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei8_tu(vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vloxei8_tu(vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei8_tu(vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei8_tu(vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei8_tu(vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei8_tu(vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei8_tu(vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei8_tu(vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei8_tu(vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei8_tu(vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei8_tu(vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8_tu(vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8_tu(vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8_tu(vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei8_tu(vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei8_tu(vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vloxei8_tu(vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m8_t test___riscv_vloxei8_tu(vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8_tu(vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8_tu(vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei8_tu(vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei8_tu(vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei8_tu(vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vloxei8_tu(vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8_tu(vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei8_tu(vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei8_tu(vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei8_tu(vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei8_tu(vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei8_tu(vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei8_tu(vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei8_tu(vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei8_tu(vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8_tu(vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8_tu(vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8_tu(vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8_tu(vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8_tu(vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8_tu(vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8_tu(vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8_tu(vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8_tu(vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_tu-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_tu-2.C
new file mode 100644
index 0000000..575514f
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_tu-2.C
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei8_tu(vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei8_tu(vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei8_tu(vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei8_tu(vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei8_tu(vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vloxei8_tu(vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vint8m8_t test___riscv_vloxei8_tu(vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei8_tu(vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei8_tu(vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei8_tu(vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei8_tu(vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei8_tu(vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vloxei8_tu(vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei8_tu(vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei8_tu(vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei8_tu(vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei8_tu(vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei8_tu(vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei8_tu(vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei8_tu(vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei8_tu(vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei8_tu(vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8_tu(vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8_tu(vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8_tu(vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei8_tu(vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei8_tu(vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vloxei8_tu(vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint8m8_t test___riscv_vloxei8_tu(vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8_tu(vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8_tu(vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei8_tu(vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei8_tu(vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei8_tu(vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vloxei8_tu(vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8_tu(vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei8_tu(vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei8_tu(vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei8_tu(vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei8_tu(vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei8_tu(vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei8_tu(vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei8_tu(vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei8_tu(vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8_tu(vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8_tu(vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8_tu(vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8_tu(vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8_tu(vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8_tu(vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8_tu(vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8_tu(vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8_tu(vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_tu-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_tu-3.C
new file mode 100644
index 0000000..da5aa77
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_tu-3.C
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei8_tu(vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei8_tu(vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei8_tu(vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei8_tu(vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei8_tu(vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vloxei8_tu(vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vint8m8_t test___riscv_vloxei8_tu(vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei8_tu(vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei8_tu(vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei8_tu(vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei8_tu(vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei8_tu(vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vloxei8_tu(vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei8_tu(vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei8_tu(vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei8_tu(vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei8_tu(vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei8_tu(vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei8_tu(vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei8_tu(vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei8_tu(vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei8_tu(vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8_tu(vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8_tu(vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8_tu(vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei8_tu(vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei8_tu(vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vloxei8_tu(vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint8m8_t test___riscv_vloxei8_tu(vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8_tu(vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8_tu(vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei8_tu(vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei8_tu(vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei8_tu(vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vloxei8_tu(vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8_tu(vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei8_tu(vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei8_tu(vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei8_tu(vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei8_tu(vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei8_tu(vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei8_tu(vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei8_tu(vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei8_tu(vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8_tu(vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8_tu(vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8_tu(vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8_tu(vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8_tu(vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8_tu(vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8_tu(vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8_tu(vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8_tu(vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tu(merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_tum-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_tum-1.C
new file mode 100644
index 0000000..54d038d
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_tum-1.C
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei8_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei8_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei8_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei8_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei8_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vloxei8_tum(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m8_t test___riscv_vloxei8_tum(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei8_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei8_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei8_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei8_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei8_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vloxei8_tum(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei8_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei8_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei8_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei8_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei8_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei8_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei8_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei8_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei8_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei8_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei8_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vloxei8_tum(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m8_t test___riscv_vloxei8_tum(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei8_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei8_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei8_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vloxei8_tum(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei8_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei8_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei8_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei8_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei8_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei8_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei8_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei8_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_tum-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_tum-2.C
new file mode 100644
index 0000000..170c7c8
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_tum-2.C
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei8_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei8_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei8_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei8_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei8_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vloxei8_tum(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m8_t test___riscv_vloxei8_tum(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei8_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei8_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei8_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei8_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei8_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vloxei8_tum(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei8_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei8_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei8_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei8_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei8_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei8_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei8_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei8_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei8_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei8_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei8_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vloxei8_tum(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m8_t test___riscv_vloxei8_tum(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei8_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei8_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei8_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vloxei8_tum(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei8_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei8_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei8_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei8_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei8_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei8_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei8_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei8_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_tum-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_tum-3.C
new file mode 100644
index 0000000..67fd325
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_tum-3.C
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei8_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei8_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei8_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei8_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei8_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vloxei8_tum(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m8_t test___riscv_vloxei8_tum(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei8_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei8_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei8_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei8_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei8_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vloxei8_tum(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei8_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei8_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei8_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei8_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei8_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei8_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei8_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei8_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei8_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei8_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei8_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vloxei8_tum(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m8_t test___riscv_vloxei8_tum(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei8_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei8_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei8_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vloxei8_tum(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei8_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei8_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei8_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei8_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei8_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei8_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei8_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei8_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_tumu-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_tumu-1.C
new file mode 100644
index 0000000..ddc84ca
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_tumu-1.C
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei8_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei8_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei8_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei8_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei8_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vloxei8_tumu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m8_t test___riscv_vloxei8_tumu(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei8_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei8_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei8_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei8_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei8_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vloxei8_tumu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei8_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei8_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei8_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei8_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei8_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei8_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei8_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei8_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei8_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei8_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei8_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vloxei8_tumu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m8_t test___riscv_vloxei8_tumu(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei8_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei8_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei8_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vloxei8_tumu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei8_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei8_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei8_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei8_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei8_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei8_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei8_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei8_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_tumu-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_tumu-2.C
new file mode 100644
index 0000000..f9f6ffc
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_tumu-2.C
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei8_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei8_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei8_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei8_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei8_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vloxei8_tumu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m8_t test___riscv_vloxei8_tumu(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei8_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei8_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei8_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei8_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei8_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vloxei8_tumu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei8_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei8_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei8_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei8_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei8_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei8_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei8_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei8_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei8_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei8_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei8_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vloxei8_tumu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m8_t test___riscv_vloxei8_tumu(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei8_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei8_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei8_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vloxei8_tumu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei8_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei8_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei8_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei8_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei8_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei8_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei8_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei8_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_tumu-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_tumu-3.C
new file mode 100644
index 0000000..462e4a29
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vloxei8_tumu-3.C
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei8_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei8_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei8_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei8_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei8_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vloxei8_tumu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m8_t test___riscv_vloxei8_tumu(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei8_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei8_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei8_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei8_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei8_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vloxei8_tumu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei8_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei8_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei8_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei8_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei8_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei8_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei8_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei8_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei8_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei8_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei8_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vloxei8_tumu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m8_t test___riscv_vloxei8_tumu(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei8_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei8_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei8_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vloxei8_tumu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei8_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei8_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei8_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei8_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei8_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei8_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei8_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei8_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vlse-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vlse-1.C
new file mode 100644
index 0000000..4c71cad
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vlse-1.C
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vlse8(vbool64_t mask,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8(mask,base,bstride,vl);
+}
+
+vint8mf4_t
+test___riscv_vlse8(vbool32_t mask,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8(mask,base,bstride,vl);
+}
+
+vint8mf2_t
+test___riscv_vlse8(vbool16_t mask,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8(mask,base,bstride,vl);
+}
+
+vint8m1_t
+test___riscv_vlse8(vbool8_t mask,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8(mask,base,bstride,vl);
+}
+
+vint8m2_t
+test___riscv_vlse8(vbool4_t mask,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8(mask,base,bstride,vl);
+}
+
+vint8m4_t
+test___riscv_vlse8(vbool2_t mask,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8(mask,base,bstride,vl);
+}
+
+vint8m8_t
+test___riscv_vlse8(vbool1_t mask,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8(mask,base,bstride,vl);
+}
+
+vuint8mf8_t
+test___riscv_vlse8(vbool64_t mask,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8(mask,base,bstride,vl);
+}
+
+vuint8mf4_t
+test___riscv_vlse8(vbool32_t mask,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8(mask,base,bstride,vl);
+}
+
+vuint8mf2_t
+test___riscv_vlse8(vbool16_t mask,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8(mask,base,bstride,vl);
+}
+
+vuint8m1_t
+test___riscv_vlse8(vbool8_t mask,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8(mask,base,bstride,vl);
+}
+
+vuint8m2_t
+test___riscv_vlse8(vbool4_t mask,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8(mask,base,bstride,vl);
+}
+
+vuint8m4_t
+test___riscv_vlse8(vbool2_t mask,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8(mask,base,bstride,vl);
+}
+
+vuint8m8_t
+test___riscv_vlse8(vbool1_t mask,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8(mask,base,bstride,vl);
+}
+
+vint16mf4_t
+test___riscv_vlse16(vbool64_t mask,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16(mask,base,bstride,vl);
+}
+
+vint16mf2_t
+test___riscv_vlse16(vbool32_t mask,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16(mask,base,bstride,vl);
+}
+
+vint16m1_t
+test___riscv_vlse16(vbool16_t mask,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16(mask,base,bstride,vl);
+}
+
+vint16m2_t
+test___riscv_vlse16(vbool8_t mask,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16(mask,base,bstride,vl);
+}
+
+vint16m4_t
+test___riscv_vlse16(vbool4_t mask,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16(mask,base,bstride,vl);
+}
+
+vint16m8_t
+test___riscv_vlse16(vbool2_t mask,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16(mask,base,bstride,vl);
+}
+
+vuint16mf4_t
+test___riscv_vlse16(vbool64_t mask,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16(mask,base,bstride,vl);
+}
+
+vuint16mf2_t
+test___riscv_vlse16(vbool32_t mask,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16(mask,base,bstride,vl);
+}
+
+vuint16m1_t
+test___riscv_vlse16(vbool16_t mask,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16(mask,base,bstride,vl);
+}
+
+vuint16m2_t
+test___riscv_vlse16(vbool8_t mask,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16(mask,base,bstride,vl);
+}
+
+vuint16m4_t
+test___riscv_vlse16(vbool4_t mask,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16(mask,base,bstride,vl);
+}
+
+vuint16m8_t
+test___riscv_vlse16(vbool2_t mask,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16(mask,base,bstride,vl);
+}
+
+vint32mf2_t
+test___riscv_vlse32(vbool64_t mask,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32(mask,base,bstride,vl);
+}
+
+vint32m1_t
+test___riscv_vlse32(vbool32_t mask,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32(mask,base,bstride,vl);
+}
+
+vint32m2_t
+test___riscv_vlse32(vbool16_t mask,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32(mask,base,bstride,vl);
+}
+
+vint32m4_t
+test___riscv_vlse32(vbool8_t mask,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32(mask,base,bstride,vl);
+}
+
+vint32m8_t
+test___riscv_vlse32(vbool4_t mask,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32(mask,base,bstride,vl);
+}
+
+vuint32mf2_t
+test___riscv_vlse32(vbool64_t mask,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32(mask,base,bstride,vl);
+}
+
+vuint32m1_t
+test___riscv_vlse32(vbool32_t mask,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32(mask,base,bstride,vl);
+}
+
+vuint32m2_t
+test___riscv_vlse32(vbool16_t mask,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32(mask,base,bstride,vl);
+}
+
+vuint32m4_t
+test___riscv_vlse32(vbool8_t mask,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32(mask,base,bstride,vl);
+}
+
+vuint32m8_t
+test___riscv_vlse32(vbool4_t mask,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32(mask,base,bstride,vl);
+}
+
+vfloat32mf2_t
+test___riscv_vlse32(vbool64_t mask,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32(mask,base,bstride,vl);
+}
+
+vfloat32m1_t
+test___riscv_vlse32(vbool32_t mask,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32(mask,base,bstride,vl);
+}
+
+vfloat32m2_t
+test___riscv_vlse32(vbool16_t mask,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32(mask,base,bstride,vl);
+}
+
+vfloat32m4_t
+test___riscv_vlse32(vbool8_t mask,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32(mask,base,bstride,vl);
+}
+
+vfloat32m8_t
+test___riscv_vlse32(vbool4_t mask,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32(mask,base,bstride,vl);
+}
+
+vint64m1_t
+test___riscv_vlse64(vbool64_t mask,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64(mask,base,bstride,vl);
+}
+
+vint64m2_t
+test___riscv_vlse64(vbool32_t mask,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64(mask,base,bstride,vl);
+}
+
+vint64m4_t
+test___riscv_vlse64(vbool16_t mask,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64(mask,base,bstride,vl);
+}
+
+vint64m8_t
+test___riscv_vlse64(vbool8_t mask,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64(mask,base,bstride,vl);
+}
+
+vuint64m1_t
+test___riscv_vlse64(vbool64_t mask,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64(mask,base,bstride,vl);
+}
+
+vuint64m2_t
+test___riscv_vlse64(vbool32_t mask,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64(mask,base,bstride,vl);
+}
+
+vuint64m4_t
+test___riscv_vlse64(vbool16_t mask,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64(mask,base,bstride,vl);
+}
+
+vuint64m8_t
+test___riscv_vlse64(vbool8_t mask,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64(mask,base,bstride,vl);
+}
+
+vfloat64m1_t
+test___riscv_vlse64(vbool64_t mask,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64(mask,base,bstride,vl);
+}
+
+vfloat64m2_t
+test___riscv_vlse64(vbool32_t mask,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64(mask,base,bstride,vl);
+}
+
+vfloat64m4_t
+test___riscv_vlse64(vbool16_t mask,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64(mask,base,bstride,vl);
+}
+
+vfloat64m8_t
+test___riscv_vlse64(vbool8_t mask,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64(mask,base,bstride,vl);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vlse_tu-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vlse_tu-1.C
new file mode 100644
index 0000000..ef75b05
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vlse_tu-1.C
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vlse8_tu(vint8mf8_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tu(merge,base,bstride,vl);
+}
+
+vint8mf4_t
+test___riscv_vlse8_tu(vint8mf4_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tu(merge,base,bstride,vl);
+}
+
+vint8mf2_t
+test___riscv_vlse8_tu(vint8mf2_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tu(merge,base,bstride,vl);
+}
+
+vint8m1_t
+test___riscv_vlse8_tu(vint8m1_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tu(merge,base,bstride,vl);
+}
+
+vint8m2_t
+test___riscv_vlse8_tu(vint8m2_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tu(merge,base,bstride,vl);
+}
+
+vint8m4_t
+test___riscv_vlse8_tu(vint8m4_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tu(merge,base,bstride,vl);
+}
+
+vint8m8_t
+test___riscv_vlse8_tu(vint8m8_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tu(merge,base,bstride,vl);
+}
+
+vuint8mf8_t
+test___riscv_vlse8_tu(vuint8mf8_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tu(merge,base,bstride,vl);
+}
+
+vuint8mf4_t
+test___riscv_vlse8_tu(vuint8mf4_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tu(merge,base,bstride,vl);
+}
+
+vuint8mf2_t
+test___riscv_vlse8_tu(vuint8mf2_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tu(merge,base,bstride,vl);
+}
+
+vuint8m1_t
+test___riscv_vlse8_tu(vuint8m1_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tu(merge,base,bstride,vl);
+}
+
+vuint8m2_t
+test___riscv_vlse8_tu(vuint8m2_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tu(merge,base,bstride,vl);
+}
+
+vuint8m4_t
+test___riscv_vlse8_tu(vuint8m4_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tu(merge,base,bstride,vl);
+}
+
+vuint8m8_t
+test___riscv_vlse8_tu(vuint8m8_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tu(merge,base,bstride,vl);
+}
+
+vint16mf4_t
+test___riscv_vlse16_tu(vint16mf4_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tu(merge,base,bstride,vl);
+}
+
+vint16mf2_t
+test___riscv_vlse16_tu(vint16mf2_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tu(merge,base,bstride,vl);
+}
+
+vint16m1_t
+test___riscv_vlse16_tu(vint16m1_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tu(merge,base,bstride,vl);
+}
+
+vint16m2_t
+test___riscv_vlse16_tu(vint16m2_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tu(merge,base,bstride,vl);
+}
+
+vint16m4_t
+test___riscv_vlse16_tu(vint16m4_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tu(merge,base,bstride,vl);
+}
+
+vint16m8_t
+test___riscv_vlse16_tu(vint16m8_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tu(merge,base,bstride,vl);
+}
+
+vuint16mf4_t
+test___riscv_vlse16_tu(vuint16mf4_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tu(merge,base,bstride,vl);
+}
+
+vuint16mf2_t
+test___riscv_vlse16_tu(vuint16mf2_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tu(merge,base,bstride,vl);
+}
+
+vuint16m1_t
+test___riscv_vlse16_tu(vuint16m1_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tu(merge,base,bstride,vl);
+}
+
+vuint16m2_t
+test___riscv_vlse16_tu(vuint16m2_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tu(merge,base,bstride,vl);
+}
+
+vuint16m4_t
+test___riscv_vlse16_tu(vuint16m4_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tu(merge,base,bstride,vl);
+}
+
+vuint16m8_t
+test___riscv_vlse16_tu(vuint16m8_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tu(merge,base,bstride,vl);
+}
+
+vint32mf2_t
+test___riscv_vlse32_tu(vint32mf2_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tu(merge,base,bstride,vl);
+}
+
+vint32m1_t
+test___riscv_vlse32_tu(vint32m1_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tu(merge,base,bstride,vl);
+}
+
+vint32m2_t
+test___riscv_vlse32_tu(vint32m2_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tu(merge,base,bstride,vl);
+}
+
+vint32m4_t
+test___riscv_vlse32_tu(vint32m4_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tu(merge,base,bstride,vl);
+}
+
+vint32m8_t
+test___riscv_vlse32_tu(vint32m8_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tu(merge,base,bstride,vl);
+}
+
+vuint32mf2_t
+test___riscv_vlse32_tu(vuint32mf2_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tu(merge,base,bstride,vl);
+}
+
+vuint32m1_t
+test___riscv_vlse32_tu(vuint32m1_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tu(merge,base,bstride,vl);
+}
+
+vuint32m2_t
+test___riscv_vlse32_tu(vuint32m2_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tu(merge,base,bstride,vl);
+}
+
+vuint32m4_t
+test___riscv_vlse32_tu(vuint32m4_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tu(merge,base,bstride,vl);
+}
+
+vuint32m8_t
+test___riscv_vlse32_tu(vuint32m8_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tu(merge,base,bstride,vl);
+}
+
+vfloat32mf2_t
+test___riscv_vlse32_tu(vfloat32mf2_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tu(merge,base,bstride,vl);
+}
+
+vfloat32m1_t
+test___riscv_vlse32_tu(vfloat32m1_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tu(merge,base,bstride,vl);
+}
+
+vfloat32m2_t
+test___riscv_vlse32_tu(vfloat32m2_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tu(merge,base,bstride,vl);
+}
+
+vfloat32m4_t
+test___riscv_vlse32_tu(vfloat32m4_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tu(merge,base,bstride,vl);
+}
+
+vfloat32m8_t
+test___riscv_vlse32_tu(vfloat32m8_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tu(merge,base,bstride,vl);
+}
+
+vint64m1_t
+test___riscv_vlse64_tu(vint64m1_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tu(merge,base,bstride,vl);
+}
+
+vint64m2_t
+test___riscv_vlse64_tu(vint64m2_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tu(merge,base,bstride,vl);
+}
+
+vint64m4_t
+test___riscv_vlse64_tu(vint64m4_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tu(merge,base,bstride,vl);
+}
+
+vint64m8_t
+test___riscv_vlse64_tu(vint64m8_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tu(merge,base,bstride,vl);
+}
+
+vuint64m1_t
+test___riscv_vlse64_tu(vuint64m1_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tu(merge,base,bstride,vl);
+}
+
+vuint64m2_t
+test___riscv_vlse64_tu(vuint64m2_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tu(merge,base,bstride,vl);
+}
+
+vuint64m4_t
+test___riscv_vlse64_tu(vuint64m4_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tu(merge,base,bstride,vl);
+}
+
+vuint64m8_t
+test___riscv_vlse64_tu(vuint64m8_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tu(merge,base,bstride,vl);
+}
+
+vfloat64m1_t
+test___riscv_vlse64_tu(vfloat64m1_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tu(merge,base,bstride,vl);
+}
+
+vfloat64m2_t
+test___riscv_vlse64_tu(vfloat64m2_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tu(merge,base,bstride,vl);
+}
+
+vfloat64m4_t
+test___riscv_vlse64_tu(vfloat64m4_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tu(merge,base,bstride,vl);
+}
+
+vfloat64m8_t
+test___riscv_vlse64_tu(vfloat64m8_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tu(merge,base,bstride,vl);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vlse_tum-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vlse_tum-1.C
new file mode 100644
index 0000000..9e05bb3
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vlse_tum-1.C
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vlse8_tum(vbool64_t mask,vint8mf8_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tum(mask,merge,base,bstride,vl);
+}
+
+vint8mf4_t
+test___riscv_vlse8_tum(vbool32_t mask,vint8mf4_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tum(mask,merge,base,bstride,vl);
+}
+
+vint8mf2_t
+test___riscv_vlse8_tum(vbool16_t mask,vint8mf2_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tum(mask,merge,base,bstride,vl);
+}
+
+vint8m1_t
+test___riscv_vlse8_tum(vbool8_t mask,vint8m1_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tum(mask,merge,base,bstride,vl);
+}
+
+vint8m2_t
+test___riscv_vlse8_tum(vbool4_t mask,vint8m2_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tum(mask,merge,base,bstride,vl);
+}
+
+vint8m4_t
+test___riscv_vlse8_tum(vbool2_t mask,vint8m4_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tum(mask,merge,base,bstride,vl);
+}
+
+vint8m8_t
+test___riscv_vlse8_tum(vbool1_t mask,vint8m8_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tum(mask,merge,base,bstride,vl);
+}
+
+vuint8mf8_t
+test___riscv_vlse8_tum(vbool64_t mask,vuint8mf8_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tum(mask,merge,base,bstride,vl);
+}
+
+vuint8mf4_t
+test___riscv_vlse8_tum(vbool32_t mask,vuint8mf4_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tum(mask,merge,base,bstride,vl);
+}
+
+vuint8mf2_t
+test___riscv_vlse8_tum(vbool16_t mask,vuint8mf2_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tum(mask,merge,base,bstride,vl);
+}
+
+vuint8m1_t
+test___riscv_vlse8_tum(vbool8_t mask,vuint8m1_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tum(mask,merge,base,bstride,vl);
+}
+
+vuint8m2_t
+test___riscv_vlse8_tum(vbool4_t mask,vuint8m2_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tum(mask,merge,base,bstride,vl);
+}
+
+vuint8m4_t
+test___riscv_vlse8_tum(vbool2_t mask,vuint8m4_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tum(mask,merge,base,bstride,vl);
+}
+
+vuint8m8_t
+test___riscv_vlse8_tum(vbool1_t mask,vuint8m8_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tum(mask,merge,base,bstride,vl);
+}
+
+vint16mf4_t
+test___riscv_vlse16_tum(vbool64_t mask,vint16mf4_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tum(mask,merge,base,bstride,vl);
+}
+
+vint16mf2_t
+test___riscv_vlse16_tum(vbool32_t mask,vint16mf2_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tum(mask,merge,base,bstride,vl);
+}
+
+vint16m1_t
+test___riscv_vlse16_tum(vbool16_t mask,vint16m1_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tum(mask,merge,base,bstride,vl);
+}
+
+vint16m2_t
+test___riscv_vlse16_tum(vbool8_t mask,vint16m2_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tum(mask,merge,base,bstride,vl);
+}
+
+vint16m4_t
+test___riscv_vlse16_tum(vbool4_t mask,vint16m4_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tum(mask,merge,base,bstride,vl);
+}
+
+vint16m8_t
+test___riscv_vlse16_tum(vbool2_t mask,vint16m8_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tum(mask,merge,base,bstride,vl);
+}
+
+vuint16mf4_t
+test___riscv_vlse16_tum(vbool64_t mask,vuint16mf4_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tum(mask,merge,base,bstride,vl);
+}
+
+vuint16mf2_t
+test___riscv_vlse16_tum(vbool32_t mask,vuint16mf2_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tum(mask,merge,base,bstride,vl);
+}
+
+vuint16m1_t
+test___riscv_vlse16_tum(vbool16_t mask,vuint16m1_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tum(mask,merge,base,bstride,vl);
+}
+
+vuint16m2_t
+test___riscv_vlse16_tum(vbool8_t mask,vuint16m2_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tum(mask,merge,base,bstride,vl);
+}
+
+vuint16m4_t
+test___riscv_vlse16_tum(vbool4_t mask,vuint16m4_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tum(mask,merge,base,bstride,vl);
+}
+
+vuint16m8_t
+test___riscv_vlse16_tum(vbool2_t mask,vuint16m8_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tum(mask,merge,base,bstride,vl);
+}
+
+vint32mf2_t
+test___riscv_vlse32_tum(vbool64_t mask,vint32mf2_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tum(mask,merge,base,bstride,vl);
+}
+
+vint32m1_t
+test___riscv_vlse32_tum(vbool32_t mask,vint32m1_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tum(mask,merge,base,bstride,vl);
+}
+
+vint32m2_t
+test___riscv_vlse32_tum(vbool16_t mask,vint32m2_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tum(mask,merge,base,bstride,vl);
+}
+
+vint32m4_t
+test___riscv_vlse32_tum(vbool8_t mask,vint32m4_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tum(mask,merge,base,bstride,vl);
+}
+
+vint32m8_t
+test___riscv_vlse32_tum(vbool4_t mask,vint32m8_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tum(mask,merge,base,bstride,vl);
+}
+
+vuint32mf2_t
+test___riscv_vlse32_tum(vbool64_t mask,vuint32mf2_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tum(mask,merge,base,bstride,vl);
+}
+
+vuint32m1_t
+test___riscv_vlse32_tum(vbool32_t mask,vuint32m1_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tum(mask,merge,base,bstride,vl);
+}
+
+vuint32m2_t
+test___riscv_vlse32_tum(vbool16_t mask,vuint32m2_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tum(mask,merge,base,bstride,vl);
+}
+
+vuint32m4_t
+test___riscv_vlse32_tum(vbool8_t mask,vuint32m4_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tum(mask,merge,base,bstride,vl);
+}
+
+vuint32m8_t
+test___riscv_vlse32_tum(vbool4_t mask,vuint32m8_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tum(mask,merge,base,bstride,vl);
+}
+
+vfloat32mf2_t
+test___riscv_vlse32_tum(vbool64_t mask,vfloat32mf2_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tum(mask,merge,base,bstride,vl);
+}
+
+vfloat32m1_t
+test___riscv_vlse32_tum(vbool32_t mask,vfloat32m1_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tum(mask,merge,base,bstride,vl);
+}
+
+vfloat32m2_t
+test___riscv_vlse32_tum(vbool16_t mask,vfloat32m2_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tum(mask,merge,base,bstride,vl);
+}
+
+vfloat32m4_t
+test___riscv_vlse32_tum(vbool8_t mask,vfloat32m4_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tum(mask,merge,base,bstride,vl);
+}
+
+vfloat32m8_t
+test___riscv_vlse32_tum(vbool4_t mask,vfloat32m8_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tum(mask,merge,base,bstride,vl);
+}
+
+vint64m1_t
+test___riscv_vlse64_tum(vbool64_t mask,vint64m1_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tum(mask,merge,base,bstride,vl);
+}
+
+vint64m2_t
+test___riscv_vlse64_tum(vbool32_t mask,vint64m2_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tum(mask,merge,base,bstride,vl);
+}
+
+vint64m4_t
+test___riscv_vlse64_tum(vbool16_t mask,vint64m4_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tum(mask,merge,base,bstride,vl);
+}
+
+vint64m8_t
+test___riscv_vlse64_tum(vbool8_t mask,vint64m8_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tum(mask,merge,base,bstride,vl);
+}
+
+vuint64m1_t
+test___riscv_vlse64_tum(vbool64_t mask,vuint64m1_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tum(mask,merge,base,bstride,vl);
+}
+
+vuint64m2_t
+test___riscv_vlse64_tum(vbool32_t mask,vuint64m2_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tum(mask,merge,base,bstride,vl);
+}
+
+vuint64m4_t
+test___riscv_vlse64_tum(vbool16_t mask,vuint64m4_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tum(mask,merge,base,bstride,vl);
+}
+
+vuint64m8_t
+test___riscv_vlse64_tum(vbool8_t mask,vuint64m8_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tum(mask,merge,base,bstride,vl);
+}
+
+vfloat64m1_t
+test___riscv_vlse64_tum(vbool64_t mask,vfloat64m1_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tum(mask,merge,base,bstride,vl);
+}
+
+vfloat64m2_t
+test___riscv_vlse64_tum(vbool32_t mask,vfloat64m2_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tum(mask,merge,base,bstride,vl);
+}
+
+vfloat64m4_t
+test___riscv_vlse64_tum(vbool16_t mask,vfloat64m4_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tum(mask,merge,base,bstride,vl);
+}
+
+vfloat64m8_t
+test___riscv_vlse64_tum(vbool8_t mask,vfloat64m8_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tum(mask,merge,base,bstride,vl);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vlse_tumu-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vlse_tumu-1.C
new file mode 100644
index 0000000..04fa611
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vlse_tumu-1.C
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vlse8_tumu(vbool64_t mask,vint8mf8_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tumu(mask,merge,base,bstride,vl);
+}
+
+vint8mf4_t
+test___riscv_vlse8_tumu(vbool32_t mask,vint8mf4_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tumu(mask,merge,base,bstride,vl);
+}
+
+vint8mf2_t
+test___riscv_vlse8_tumu(vbool16_t mask,vint8mf2_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tumu(mask,merge,base,bstride,vl);
+}
+
+vint8m1_t
+test___riscv_vlse8_tumu(vbool8_t mask,vint8m1_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tumu(mask,merge,base,bstride,vl);
+}
+
+vint8m2_t
+test___riscv_vlse8_tumu(vbool4_t mask,vint8m2_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tumu(mask,merge,base,bstride,vl);
+}
+
+vint8m4_t
+test___riscv_vlse8_tumu(vbool2_t mask,vint8m4_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tumu(mask,merge,base,bstride,vl);
+}
+
+vint8m8_t
+test___riscv_vlse8_tumu(vbool1_t mask,vint8m8_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint8mf8_t
+test___riscv_vlse8_tumu(vbool64_t mask,vuint8mf8_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint8mf4_t
+test___riscv_vlse8_tumu(vbool32_t mask,vuint8mf4_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint8mf2_t
+test___riscv_vlse8_tumu(vbool16_t mask,vuint8mf2_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint8m1_t
+test___riscv_vlse8_tumu(vbool8_t mask,vuint8m1_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint8m2_t
+test___riscv_vlse8_tumu(vbool4_t mask,vuint8m2_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint8m4_t
+test___riscv_vlse8_tumu(vbool2_t mask,vuint8m4_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint8m8_t
+test___riscv_vlse8_tumu(vbool1_t mask,vuint8m8_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_tumu(mask,merge,base,bstride,vl);
+}
+
+vint16mf4_t
+test___riscv_vlse16_tumu(vbool64_t mask,vint16mf4_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tumu(mask,merge,base,bstride,vl);
+}
+
+vint16mf2_t
+test___riscv_vlse16_tumu(vbool32_t mask,vint16mf2_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tumu(mask,merge,base,bstride,vl);
+}
+
+vint16m1_t
+test___riscv_vlse16_tumu(vbool16_t mask,vint16m1_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tumu(mask,merge,base,bstride,vl);
+}
+
+vint16m2_t
+test___riscv_vlse16_tumu(vbool8_t mask,vint16m2_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tumu(mask,merge,base,bstride,vl);
+}
+
+vint16m4_t
+test___riscv_vlse16_tumu(vbool4_t mask,vint16m4_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tumu(mask,merge,base,bstride,vl);
+}
+
+vint16m8_t
+test___riscv_vlse16_tumu(vbool2_t mask,vint16m8_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint16mf4_t
+test___riscv_vlse16_tumu(vbool64_t mask,vuint16mf4_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint16mf2_t
+test___riscv_vlse16_tumu(vbool32_t mask,vuint16mf2_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint16m1_t
+test___riscv_vlse16_tumu(vbool16_t mask,vuint16m1_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint16m2_t
+test___riscv_vlse16_tumu(vbool8_t mask,vuint16m2_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint16m4_t
+test___riscv_vlse16_tumu(vbool4_t mask,vuint16m4_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint16m8_t
+test___riscv_vlse16_tumu(vbool2_t mask,vuint16m8_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_tumu(mask,merge,base,bstride,vl);
+}
+
+vint32mf2_t
+test___riscv_vlse32_tumu(vbool64_t mask,vint32mf2_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tumu(mask,merge,base,bstride,vl);
+}
+
+vint32m1_t
+test___riscv_vlse32_tumu(vbool32_t mask,vint32m1_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tumu(mask,merge,base,bstride,vl);
+}
+
+vint32m2_t
+test___riscv_vlse32_tumu(vbool16_t mask,vint32m2_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tumu(mask,merge,base,bstride,vl);
+}
+
+vint32m4_t
+test___riscv_vlse32_tumu(vbool8_t mask,vint32m4_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tumu(mask,merge,base,bstride,vl);
+}
+
+vint32m8_t
+test___riscv_vlse32_tumu(vbool4_t mask,vint32m8_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint32mf2_t
+test___riscv_vlse32_tumu(vbool64_t mask,vuint32mf2_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint32m1_t
+test___riscv_vlse32_tumu(vbool32_t mask,vuint32m1_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint32m2_t
+test___riscv_vlse32_tumu(vbool16_t mask,vuint32m2_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint32m4_t
+test___riscv_vlse32_tumu(vbool8_t mask,vuint32m4_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint32m8_t
+test___riscv_vlse32_tumu(vbool4_t mask,vuint32m8_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tumu(mask,merge,base,bstride,vl);
+}
+
+vfloat32mf2_t
+test___riscv_vlse32_tumu(vbool64_t mask,vfloat32mf2_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tumu(mask,merge,base,bstride,vl);
+}
+
+vfloat32m1_t
+test___riscv_vlse32_tumu(vbool32_t mask,vfloat32m1_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tumu(mask,merge,base,bstride,vl);
+}
+
+vfloat32m2_t
+test___riscv_vlse32_tumu(vbool16_t mask,vfloat32m2_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tumu(mask,merge,base,bstride,vl);
+}
+
+vfloat32m4_t
+test___riscv_vlse32_tumu(vbool8_t mask,vfloat32m4_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tumu(mask,merge,base,bstride,vl);
+}
+
+vfloat32m8_t
+test___riscv_vlse32_tumu(vbool4_t mask,vfloat32m8_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_tumu(mask,merge,base,bstride,vl);
+}
+
+vint64m1_t
+test___riscv_vlse64_tumu(vbool64_t mask,vint64m1_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tumu(mask,merge,base,bstride,vl);
+}
+
+vint64m2_t
+test___riscv_vlse64_tumu(vbool32_t mask,vint64m2_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tumu(mask,merge,base,bstride,vl);
+}
+
+vint64m4_t
+test___riscv_vlse64_tumu(vbool16_t mask,vint64m4_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tumu(mask,merge,base,bstride,vl);
+}
+
+vint64m8_t
+test___riscv_vlse64_tumu(vbool8_t mask,vint64m8_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint64m1_t
+test___riscv_vlse64_tumu(vbool64_t mask,vuint64m1_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint64m2_t
+test___riscv_vlse64_tumu(vbool32_t mask,vuint64m2_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint64m4_t
+test___riscv_vlse64_tumu(vbool16_t mask,vuint64m4_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint64m8_t
+test___riscv_vlse64_tumu(vbool8_t mask,vuint64m8_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tumu(mask,merge,base,bstride,vl);
+}
+
+vfloat64m1_t
+test___riscv_vlse64_tumu(vbool64_t mask,vfloat64m1_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tumu(mask,merge,base,bstride,vl);
+}
+
+vfloat64m2_t
+test___riscv_vlse64_tumu(vbool32_t mask,vfloat64m2_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tumu(mask,merge,base,bstride,vl);
+}
+
+vfloat64m4_t
+test___riscv_vlse64_tumu(vbool16_t mask,vfloat64m4_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tumu(mask,merge,base,bstride,vl);
+}
+
+vfloat64m8_t
+test___riscv_vlse64_tumu(vbool8_t mask,vfloat64m8_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_tumu(mask,merge,base,bstride,vl);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*mu\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16-1.C
new file mode 100644
index 0000000..c8b7268
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16-1.C
@@ -0,0 +1,660 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei16(const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei16(const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei16(const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei16(const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei16(const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vluxei16(const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei16(const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei16(const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei16(const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei16(const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei16(const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vluxei16(const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei16(const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei16(const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei16(const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei16(const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei16(const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei16(const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei16(const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei16(const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei16(const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16(const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16(const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16(const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei16(const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei16(const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vluxei16(const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16(const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16(const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei16(const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei16(const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei16(const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vluxei16(const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16(const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei16(const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei16(const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei16(const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei16(const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei16(const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei16(const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei16(const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei16(const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16(const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16(const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16(const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16(const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16(const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16(const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16(const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16(const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16(const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,vl);
+}
+
+
+vint8mf8_t test___riscv_vluxei16(vbool64_t mask,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei16(vbool32_t mask,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei16(vbool16_t mask,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei16(vbool8_t mask,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei16(vbool4_t mask,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vluxei16(vbool2_t mask,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei16(vbool64_t mask,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei16(vbool32_t mask,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei16(vbool16_t mask,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei16(vbool8_t mask,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei16(vbool4_t mask,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vluxei16(vbool2_t mask,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei16(vbool64_t mask,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei16(vbool32_t mask,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei16(vbool16_t mask,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei16(vbool8_t mask,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei16(vbool4_t mask,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei16(vbool64_t mask,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei16(vbool32_t mask,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei16(vbool16_t mask,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei16(vbool8_t mask,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16(vbool64_t mask,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16(vbool32_t mask,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16(vbool16_t mask,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei16(vbool8_t mask,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei16(vbool4_t mask,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vluxei16(vbool2_t mask,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16(vbool64_t mask,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16(vbool32_t mask,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei16(vbool16_t mask,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei16(vbool8_t mask,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei16(vbool4_t mask,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vluxei16(vbool2_t mask,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16(vbool64_t mask,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei16(vbool32_t mask,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei16(vbool16_t mask,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei16(vbool8_t mask,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei16(vbool4_t mask,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei16(vbool64_t mask,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei16(vbool32_t mask,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei16(vbool16_t mask,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei16(vbool8_t mask,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16(vbool64_t mask,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16(vbool32_t mask,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16(vbool16_t mask,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16(vbool8_t mask,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16(vbool4_t mask,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16(vbool64_t mask,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16(vbool32_t mask,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16(vbool16_t mask,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16(vbool8_t mask,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16-2.C
new file mode 100644
index 0000000..cdf644e
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16-2.C
@@ -0,0 +1,660 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei16(const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei16(const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei16(const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei16(const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei16(const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vluxei16(const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei16(const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei16(const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei16(const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei16(const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei16(const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vluxei16(const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei16(const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei16(const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei16(const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei16(const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei16(const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei16(const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei16(const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei16(const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei16(const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16(const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16(const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16(const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei16(const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei16(const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vluxei16(const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16(const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16(const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei16(const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei16(const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei16(const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vluxei16(const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16(const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei16(const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei16(const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei16(const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei16(const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei16(const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei16(const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei16(const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei16(const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16(const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16(const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16(const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16(const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16(const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16(const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16(const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16(const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16(const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,31);
+}
+
+
+vint8mf8_t test___riscv_vluxei16(vbool64_t mask,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei16(vbool32_t mask,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei16(vbool16_t mask,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei16(vbool8_t mask,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei16(vbool4_t mask,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vluxei16(vbool2_t mask,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei16(vbool64_t mask,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei16(vbool32_t mask,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei16(vbool16_t mask,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei16(vbool8_t mask,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei16(vbool4_t mask,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vluxei16(vbool2_t mask,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei16(vbool64_t mask,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei16(vbool32_t mask,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei16(vbool16_t mask,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei16(vbool8_t mask,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei16(vbool4_t mask,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei16(vbool64_t mask,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei16(vbool32_t mask,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei16(vbool16_t mask,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei16(vbool8_t mask,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16(vbool64_t mask,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16(vbool32_t mask,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16(vbool16_t mask,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei16(vbool8_t mask,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei16(vbool4_t mask,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vluxei16(vbool2_t mask,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16(vbool64_t mask,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16(vbool32_t mask,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei16(vbool16_t mask,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei16(vbool8_t mask,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei16(vbool4_t mask,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vluxei16(vbool2_t mask,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16(vbool64_t mask,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei16(vbool32_t mask,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei16(vbool16_t mask,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei16(vbool8_t mask,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei16(vbool4_t mask,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei16(vbool64_t mask,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei16(vbool32_t mask,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei16(vbool16_t mask,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei16(vbool8_t mask,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16(vbool64_t mask,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16(vbool32_t mask,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16(vbool16_t mask,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16(vbool8_t mask,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16(vbool4_t mask,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16(vbool64_t mask,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16(vbool32_t mask,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16(vbool16_t mask,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16(vbool8_t mask,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16-3.C
new file mode 100644
index 0000000..8412456
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16-3.C
@@ -0,0 +1,660 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei16(const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei16(const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei16(const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei16(const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei16(const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vluxei16(const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei16(const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei16(const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei16(const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei16(const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei16(const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vluxei16(const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei16(const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei16(const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei16(const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei16(const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei16(const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei16(const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei16(const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei16(const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei16(const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16(const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16(const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16(const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei16(const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei16(const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vluxei16(const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16(const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16(const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei16(const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei16(const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei16(const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vluxei16(const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16(const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei16(const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei16(const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei16(const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei16(const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei16(const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei16(const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei16(const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei16(const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16(const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16(const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16(const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16(const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16(const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16(const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16(const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16(const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16(const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(base,bindex,32);
+}
+
+
+vint8mf8_t test___riscv_vluxei16(vbool64_t mask,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei16(vbool32_t mask,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei16(vbool16_t mask,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei16(vbool8_t mask,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei16(vbool4_t mask,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vluxei16(vbool2_t mask,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei16(vbool64_t mask,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei16(vbool32_t mask,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei16(vbool16_t mask,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei16(vbool8_t mask,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei16(vbool4_t mask,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vluxei16(vbool2_t mask,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei16(vbool64_t mask,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei16(vbool32_t mask,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei16(vbool16_t mask,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei16(vbool8_t mask,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei16(vbool4_t mask,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei16(vbool64_t mask,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei16(vbool32_t mask,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei16(vbool16_t mask,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei16(vbool8_t mask,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16(vbool64_t mask,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16(vbool32_t mask,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16(vbool16_t mask,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei16(vbool8_t mask,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei16(vbool4_t mask,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vluxei16(vbool2_t mask,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16(vbool64_t mask,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16(vbool32_t mask,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei16(vbool16_t mask,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei16(vbool8_t mask,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei16(vbool4_t mask,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vluxei16(vbool2_t mask,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16(vbool64_t mask,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei16(vbool32_t mask,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei16(vbool16_t mask,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei16(vbool8_t mask,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei16(vbool4_t mask,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei16(vbool64_t mask,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei16(vbool32_t mask,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei16(vbool16_t mask,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei16(vbool8_t mask,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16(vbool64_t mask,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16(vbool32_t mask,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16(vbool16_t mask,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16(vbool8_t mask,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16(vbool4_t mask,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16(vbool64_t mask,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16(vbool32_t mask,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16(vbool16_t mask,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16(vbool8_t mask,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16(mask,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_mu-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_mu-1.C
new file mode 100644
index 0000000..ec8a724
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_mu-1.C
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei16_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei16_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei16_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei16_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei16_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vluxei16_mu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei16_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei16_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei16_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei16_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei16_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vluxei16_mu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei16_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei16_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei16_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei16_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei16_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei16_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei16_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei16_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei16_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei16_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei16_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vluxei16_mu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei16_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei16_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei16_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vluxei16_mu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei16_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei16_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei16_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei16_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei16_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei16_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei16_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei16_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_mu-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_mu-2.C
new file mode 100644
index 0000000..b914c13
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_mu-2.C
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei16_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei16_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei16_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei16_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei16_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vluxei16_mu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei16_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei16_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei16_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei16_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei16_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vluxei16_mu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei16_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei16_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei16_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei16_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei16_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei16_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei16_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei16_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei16_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei16_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei16_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vluxei16_mu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei16_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei16_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei16_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vluxei16_mu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei16_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei16_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei16_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei16_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei16_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei16_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei16_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei16_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_mu-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_mu-3.C
new file mode 100644
index 0000000..0cb2c6c
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_mu-3.C
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei16_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei16_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei16_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei16_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei16_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vluxei16_mu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei16_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei16_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei16_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei16_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei16_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vluxei16_mu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei16_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei16_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei16_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei16_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei16_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei16_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei16_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei16_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei16_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei16_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei16_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vluxei16_mu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei16_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei16_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei16_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vluxei16_mu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei16_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei16_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei16_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei16_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei16_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei16_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei16_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei16_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_mu(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_tu-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_tu-1.C
new file mode 100644
index 0000000..52500ef
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_tu-1.C
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei16_tu(vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei16_tu(vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei16_tu(vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei16_tu(vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei16_tu(vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vluxei16_tu(vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei16_tu(vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei16_tu(vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei16_tu(vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei16_tu(vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei16_tu(vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vluxei16_tu(vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei16_tu(vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei16_tu(vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei16_tu(vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei16_tu(vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei16_tu(vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei16_tu(vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei16_tu(vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei16_tu(vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei16_tu(vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16_tu(vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16_tu(vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16_tu(vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei16_tu(vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei16_tu(vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vluxei16_tu(vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16_tu(vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16_tu(vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei16_tu(vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei16_tu(vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei16_tu(vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vluxei16_tu(vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16_tu(vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei16_tu(vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei16_tu(vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei16_tu(vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei16_tu(vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei16_tu(vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei16_tu(vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei16_tu(vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei16_tu(vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16_tu(vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16_tu(vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16_tu(vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16_tu(vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16_tu(vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16_tu(vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16_tu(vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16_tu(vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16_tu(vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_tu-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_tu-2.C
new file mode 100644
index 0000000..d736702
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_tu-2.C
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei16_tu(vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei16_tu(vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei16_tu(vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei16_tu(vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei16_tu(vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vluxei16_tu(vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei16_tu(vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei16_tu(vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei16_tu(vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei16_tu(vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei16_tu(vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vluxei16_tu(vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei16_tu(vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei16_tu(vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei16_tu(vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei16_tu(vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei16_tu(vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei16_tu(vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei16_tu(vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei16_tu(vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei16_tu(vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16_tu(vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16_tu(vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16_tu(vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei16_tu(vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei16_tu(vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vluxei16_tu(vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16_tu(vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16_tu(vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei16_tu(vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei16_tu(vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei16_tu(vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vluxei16_tu(vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16_tu(vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei16_tu(vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei16_tu(vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei16_tu(vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei16_tu(vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei16_tu(vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei16_tu(vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei16_tu(vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei16_tu(vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16_tu(vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16_tu(vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16_tu(vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16_tu(vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16_tu(vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16_tu(vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16_tu(vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16_tu(vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16_tu(vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_tu-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_tu-3.C
new file mode 100644
index 0000000..026731a
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_tu-3.C
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei16_tu(vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei16_tu(vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei16_tu(vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei16_tu(vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei16_tu(vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vluxei16_tu(vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei16_tu(vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei16_tu(vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei16_tu(vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei16_tu(vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei16_tu(vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vluxei16_tu(vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei16_tu(vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei16_tu(vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei16_tu(vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei16_tu(vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei16_tu(vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei16_tu(vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei16_tu(vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei16_tu(vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei16_tu(vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16_tu(vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16_tu(vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16_tu(vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei16_tu(vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei16_tu(vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vluxei16_tu(vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16_tu(vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16_tu(vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei16_tu(vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei16_tu(vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei16_tu(vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vluxei16_tu(vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16_tu(vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei16_tu(vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei16_tu(vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei16_tu(vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei16_tu(vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei16_tu(vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei16_tu(vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei16_tu(vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei16_tu(vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16_tu(vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16_tu(vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16_tu(vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16_tu(vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16_tu(vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16_tu(vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16_tu(vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16_tu(vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16_tu(vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tu(merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_tum-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_tum-1.C
new file mode 100644
index 0000000..09d1850
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_tum-1.C
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei16_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei16_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei16_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei16_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei16_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vluxei16_tum(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei16_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei16_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei16_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei16_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei16_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vluxei16_tum(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei16_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei16_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei16_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei16_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei16_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei16_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei16_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei16_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei16_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei16_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei16_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vluxei16_tum(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei16_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei16_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei16_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vluxei16_tum(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei16_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei16_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei16_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei16_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei16_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei16_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei16_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei16_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_tum-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_tum-2.C
new file mode 100644
index 0000000..e58a85a
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_tum-2.C
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei16_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei16_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei16_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei16_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei16_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vluxei16_tum(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei16_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei16_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei16_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei16_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei16_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vluxei16_tum(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei16_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei16_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei16_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei16_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei16_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei16_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei16_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei16_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei16_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei16_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei16_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vluxei16_tum(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei16_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei16_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei16_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vluxei16_tum(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei16_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei16_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei16_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei16_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei16_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei16_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei16_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei16_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_tum-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_tum-3.C
new file mode 100644
index 0000000..b517022
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_tum-3.C
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei16_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei16_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei16_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei16_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei16_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vluxei16_tum(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei16_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei16_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei16_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei16_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei16_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vluxei16_tum(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei16_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei16_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei16_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei16_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei16_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei16_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei16_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei16_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei16_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei16_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei16_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vluxei16_tum(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei16_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei16_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei16_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vluxei16_tum(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei16_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei16_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei16_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei16_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei16_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei16_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei16_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei16_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tum(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_tumu-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_tumu-1.C
new file mode 100644
index 0000000..03ff7f7
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_tumu-1.C
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei16_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei16_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei16_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei16_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei16_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vluxei16_tumu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei16_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei16_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei16_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei16_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei16_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vluxei16_tumu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei16_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei16_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei16_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei16_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei16_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei16_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei16_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei16_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei16_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei16_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei16_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vluxei16_tumu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei16_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei16_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei16_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vluxei16_tumu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei16_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei16_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei16_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei16_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei16_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei16_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei16_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei16_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_tumu-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_tumu-2.C
new file mode 100644
index 0000000..51d794e
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_tumu-2.C
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei16_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei16_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei16_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei16_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei16_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vluxei16_tumu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei16_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei16_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei16_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei16_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei16_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vluxei16_tumu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei16_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei16_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei16_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei16_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei16_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei16_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei16_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei16_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei16_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei16_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei16_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vluxei16_tumu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei16_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei16_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei16_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vluxei16_tumu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei16_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei16_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei16_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei16_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei16_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei16_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei16_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei16_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_tumu-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_tumu-3.C
new file mode 100644
index 0000000..285afaf
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei16_tumu-3.C
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei16_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei16_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei16_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei16_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei16_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vluxei16_tumu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei16_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei16_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei16_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei16_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei16_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vluxei16_tumu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei16_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei16_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei16_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei16_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei16_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei16_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei16_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei16_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei16_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei16_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei16_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vluxei16_tumu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei16_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei16_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei16_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vluxei16_tumu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei16_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei16_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei16_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei16_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei16_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei16_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei16_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei16_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_tumu(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32-1.C
new file mode 100644
index 0000000..8003397
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32-1.C
@@ -0,0 +1,608 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei32(const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei32(const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei32(const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei32(const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei32(const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei32(const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei32(const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei32(const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei32(const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei32(const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei32(const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei32(const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei32(const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei32(const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei32(const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei32(const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei32(const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei32(const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei32(const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32(const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32(const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32(const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei32(const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei32(const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32(const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32(const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei32(const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei32(const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei32(const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32(const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei32(const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei32(const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei32(const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei32(const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei32(const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei32(const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei32(const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei32(const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32(const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32(const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32(const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32(const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32(const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32(const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32(const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32(const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32(const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,vl);
+}
+
+
+vint8mf8_t test___riscv_vluxei32(vbool64_t mask,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei32(vbool32_t mask,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei32(vbool16_t mask,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei32(vbool8_t mask,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei32(vbool4_t mask,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei32(vbool64_t mask,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei32(vbool32_t mask,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei32(vbool16_t mask,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei32(vbool8_t mask,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei32(vbool4_t mask,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei32(vbool64_t mask,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei32(vbool32_t mask,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei32(vbool16_t mask,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei32(vbool8_t mask,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei32(vbool4_t mask,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei32(vbool64_t mask,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei32(vbool32_t mask,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei32(vbool16_t mask,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei32(vbool8_t mask,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32(vbool64_t mask,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32(vbool32_t mask,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32(vbool16_t mask,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei32(vbool8_t mask,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei32(vbool4_t mask,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32(vbool64_t mask,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32(vbool32_t mask,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei32(vbool16_t mask,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei32(vbool8_t mask,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei32(vbool4_t mask,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32(vbool64_t mask,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei32(vbool32_t mask,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei32(vbool16_t mask,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei32(vbool8_t mask,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei32(vbool4_t mask,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei32(vbool64_t mask,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei32(vbool32_t mask,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei32(vbool16_t mask,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei32(vbool8_t mask,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32(vbool64_t mask,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32(vbool32_t mask,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32(vbool16_t mask,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32(vbool8_t mask,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32(vbool4_t mask,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32(vbool64_t mask,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32(vbool32_t mask,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32(vbool16_t mask,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32(vbool8_t mask,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32-2.C
new file mode 100644
index 0000000..57380cd
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32-2.C
@@ -0,0 +1,608 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei32(const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei32(const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei32(const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei32(const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei32(const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei32(const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei32(const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei32(const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei32(const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei32(const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei32(const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei32(const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei32(const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei32(const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei32(const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei32(const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei32(const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei32(const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei32(const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32(const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32(const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32(const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei32(const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei32(const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32(const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32(const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei32(const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei32(const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei32(const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32(const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei32(const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei32(const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei32(const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei32(const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei32(const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei32(const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei32(const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei32(const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32(const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32(const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32(const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32(const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32(const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32(const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32(const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32(const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32(const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,31);
+}
+
+
+vint8mf8_t test___riscv_vluxei32(vbool64_t mask,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei32(vbool32_t mask,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei32(vbool16_t mask,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei32(vbool8_t mask,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei32(vbool4_t mask,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei32(vbool64_t mask,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei32(vbool32_t mask,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei32(vbool16_t mask,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei32(vbool8_t mask,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei32(vbool4_t mask,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei32(vbool64_t mask,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei32(vbool32_t mask,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei32(vbool16_t mask,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei32(vbool8_t mask,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei32(vbool4_t mask,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei32(vbool64_t mask,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei32(vbool32_t mask,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei32(vbool16_t mask,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei32(vbool8_t mask,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32(vbool64_t mask,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32(vbool32_t mask,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32(vbool16_t mask,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei32(vbool8_t mask,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei32(vbool4_t mask,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32(vbool64_t mask,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32(vbool32_t mask,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei32(vbool16_t mask,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei32(vbool8_t mask,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei32(vbool4_t mask,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32(vbool64_t mask,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei32(vbool32_t mask,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei32(vbool16_t mask,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei32(vbool8_t mask,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei32(vbool4_t mask,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei32(vbool64_t mask,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei32(vbool32_t mask,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei32(vbool16_t mask,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei32(vbool8_t mask,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32(vbool64_t mask,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32(vbool32_t mask,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32(vbool16_t mask,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32(vbool8_t mask,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32(vbool4_t mask,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32(vbool64_t mask,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32(vbool32_t mask,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32(vbool16_t mask,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32(vbool8_t mask,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32-3.C
new file mode 100644
index 0000000..be9a27e
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32-3.C
@@ -0,0 +1,608 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei32(const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei32(const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei32(const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei32(const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei32(const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei32(const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei32(const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei32(const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei32(const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei32(const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei32(const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei32(const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei32(const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei32(const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei32(const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei32(const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei32(const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei32(const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei32(const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32(const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32(const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32(const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei32(const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei32(const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32(const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32(const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei32(const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei32(const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei32(const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32(const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei32(const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei32(const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei32(const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei32(const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei32(const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei32(const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei32(const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei32(const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32(const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32(const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32(const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32(const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32(const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32(const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32(const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32(const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32(const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(base,bindex,32);
+}
+
+
+vint8mf8_t test___riscv_vluxei32(vbool64_t mask,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei32(vbool32_t mask,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei32(vbool16_t mask,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei32(vbool8_t mask,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei32(vbool4_t mask,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei32(vbool64_t mask,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei32(vbool32_t mask,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei32(vbool16_t mask,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei32(vbool8_t mask,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei32(vbool4_t mask,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei32(vbool64_t mask,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei32(vbool32_t mask,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei32(vbool16_t mask,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei32(vbool8_t mask,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei32(vbool4_t mask,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei32(vbool64_t mask,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei32(vbool32_t mask,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei32(vbool16_t mask,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei32(vbool8_t mask,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32(vbool64_t mask,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32(vbool32_t mask,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32(vbool16_t mask,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei32(vbool8_t mask,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei32(vbool4_t mask,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32(vbool64_t mask,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32(vbool32_t mask,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei32(vbool16_t mask,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei32(vbool8_t mask,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei32(vbool4_t mask,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32(vbool64_t mask,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei32(vbool32_t mask,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei32(vbool16_t mask,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei32(vbool8_t mask,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei32(vbool4_t mask,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei32(vbool64_t mask,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei32(vbool32_t mask,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei32(vbool16_t mask,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei32(vbool8_t mask,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32(vbool64_t mask,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32(vbool32_t mask,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32(vbool16_t mask,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32(vbool8_t mask,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32(vbool4_t mask,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32(vbool64_t mask,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32(vbool32_t mask,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32(vbool16_t mask,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32(vbool8_t mask,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32(mask,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_mu-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_mu-1.C
new file mode 100644
index 0000000..b6e3b5d
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_mu-1.C
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei32_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei32_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei32_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei32_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei32_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei32_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei32_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei32_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei32_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei32_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei32_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei32_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei32_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei32_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei32_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei32_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei32_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei32_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei32_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei32_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei32_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei32_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei32_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei32_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei32_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei32_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei32_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei32_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei32_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei32_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei32_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei32_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_mu-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_mu-2.C
new file mode 100644
index 0000000..4538c8c
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_mu-2.C
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei32_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei32_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei32_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei32_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei32_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei32_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei32_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei32_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei32_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei32_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei32_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei32_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei32_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei32_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei32_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei32_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei32_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei32_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei32_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei32_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei32_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei32_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei32_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei32_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei32_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei32_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei32_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei32_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei32_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei32_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei32_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei32_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_mu-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_mu-3.C
new file mode 100644
index 0000000..540cf19
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_mu-3.C
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei32_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei32_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei32_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei32_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei32_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei32_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei32_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei32_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei32_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei32_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei32_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei32_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei32_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei32_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei32_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei32_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei32_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei32_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei32_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei32_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei32_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei32_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei32_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei32_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei32_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei32_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei32_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei32_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei32_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei32_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei32_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei32_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_mu(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_tu-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_tu-1.C
new file mode 100644
index 0000000..4d68e87
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_tu-1.C
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei32_tu(vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei32_tu(vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei32_tu(vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei32_tu(vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei32_tu(vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei32_tu(vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei32_tu(vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei32_tu(vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei32_tu(vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei32_tu(vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei32_tu(vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei32_tu(vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei32_tu(vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei32_tu(vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei32_tu(vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei32_tu(vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei32_tu(vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei32_tu(vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei32_tu(vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32_tu(vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32_tu(vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32_tu(vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei32_tu(vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei32_tu(vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32_tu(vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32_tu(vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei32_tu(vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei32_tu(vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei32_tu(vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32_tu(vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei32_tu(vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei32_tu(vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei32_tu(vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei32_tu(vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei32_tu(vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei32_tu(vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei32_tu(vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei32_tu(vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32_tu(vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32_tu(vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32_tu(vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32_tu(vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32_tu(vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32_tu(vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32_tu(vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32_tu(vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32_tu(vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_tu-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_tu-2.C
new file mode 100644
index 0000000..20e27d4
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_tu-2.C
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei32_tu(vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei32_tu(vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei32_tu(vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei32_tu(vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei32_tu(vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei32_tu(vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei32_tu(vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei32_tu(vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei32_tu(vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei32_tu(vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei32_tu(vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei32_tu(vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei32_tu(vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei32_tu(vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei32_tu(vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei32_tu(vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei32_tu(vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei32_tu(vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei32_tu(vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32_tu(vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32_tu(vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32_tu(vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei32_tu(vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei32_tu(vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32_tu(vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32_tu(vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei32_tu(vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei32_tu(vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei32_tu(vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32_tu(vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei32_tu(vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei32_tu(vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei32_tu(vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei32_tu(vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei32_tu(vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei32_tu(vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei32_tu(vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei32_tu(vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32_tu(vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32_tu(vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32_tu(vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32_tu(vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32_tu(vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32_tu(vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32_tu(vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32_tu(vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32_tu(vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_tu-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_tu-3.C
new file mode 100644
index 0000000..fda3a0b
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_tu-3.C
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei32_tu(vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei32_tu(vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei32_tu(vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei32_tu(vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei32_tu(vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei32_tu(vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei32_tu(vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei32_tu(vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei32_tu(vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei32_tu(vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei32_tu(vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei32_tu(vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei32_tu(vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei32_tu(vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei32_tu(vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei32_tu(vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei32_tu(vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei32_tu(vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei32_tu(vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32_tu(vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32_tu(vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32_tu(vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei32_tu(vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei32_tu(vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32_tu(vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32_tu(vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei32_tu(vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei32_tu(vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei32_tu(vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32_tu(vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei32_tu(vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei32_tu(vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei32_tu(vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei32_tu(vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei32_tu(vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei32_tu(vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei32_tu(vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei32_tu(vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32_tu(vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32_tu(vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32_tu(vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32_tu(vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32_tu(vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32_tu(vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32_tu(vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32_tu(vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32_tu(vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tu(merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_tum-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_tum-1.C
new file mode 100644
index 0000000..a5966df
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_tum-1.C
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei32_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei32_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei32_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei32_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei32_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei32_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei32_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei32_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei32_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei32_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei32_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei32_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei32_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei32_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei32_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei32_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei32_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei32_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei32_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei32_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei32_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei32_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei32_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei32_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei32_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei32_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei32_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei32_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei32_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei32_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei32_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei32_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_tum-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_tum-2.C
new file mode 100644
index 0000000..c1b8c29
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_tum-2.C
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei32_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei32_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei32_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei32_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei32_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei32_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei32_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei32_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei32_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei32_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei32_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei32_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei32_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei32_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei32_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei32_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei32_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei32_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei32_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei32_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei32_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei32_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei32_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei32_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei32_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei32_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei32_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei32_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei32_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei32_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei32_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei32_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_tum-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_tum-3.C
new file mode 100644
index 0000000..7acee66
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_tum-3.C
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei32_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei32_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei32_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei32_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei32_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei32_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei32_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei32_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei32_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei32_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei32_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei32_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei32_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei32_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei32_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei32_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei32_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei32_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei32_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei32_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei32_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei32_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei32_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei32_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei32_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei32_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei32_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei32_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei32_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei32_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei32_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei32_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tum(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_tumu-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_tumu-1.C
new file mode 100644
index 0000000..e7562f4
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_tumu-1.C
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei32_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei32_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei32_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei32_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei32_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei32_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei32_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei32_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei32_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei32_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei32_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei32_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei32_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei32_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei32_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei32_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei32_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei32_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei32_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei32_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei32_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei32_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei32_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei32_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei32_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei32_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei32_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei32_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei32_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei32_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei32_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei32_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_tumu-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_tumu-2.C
new file mode 100644
index 0000000..b8c8443
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_tumu-2.C
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei32_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei32_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei32_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei32_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei32_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei32_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei32_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei32_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei32_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei32_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei32_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei32_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei32_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei32_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei32_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei32_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei32_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei32_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei32_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei32_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei32_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei32_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei32_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei32_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei32_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei32_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei32_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei32_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei32_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei32_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei32_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei32_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_tumu-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_tumu-3.C
new file mode 100644
index 0000000..05b7068
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei32_tumu-3.C
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei32_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei32_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei32_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei32_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei32_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei32_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei32_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei32_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei32_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei32_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei32_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei32_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei32_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei32_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei32_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei32_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei32_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei32_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei32_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei32_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei32_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei32_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei32_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei32_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei32_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei32_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei32_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei32_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei32_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei32_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei32_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei32_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_tumu(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64-1.C
new file mode 100644
index 0000000..a9715c0
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64-1.C
@@ -0,0 +1,518 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei64(const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei64(const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei64(const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei64(const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei64(const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei64(const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei64(const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei64(const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei64(const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei64(const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei64(const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei64(const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei64(const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei64(const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei64(const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei64(const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64(const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64(const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64(const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei64(const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64(const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64(const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei64(const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei64(const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64(const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei64(const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei64(const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei64(const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei64(const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei64(const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei64(const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei64(const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64(const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64(const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64(const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64(const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64(const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64(const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64(const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64(const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,vl);
+}
+
+
+vint8mf8_t test___riscv_vluxei64(vbool64_t mask,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei64(vbool32_t mask,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei64(vbool16_t mask,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei64(vbool8_t mask,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei64(vbool64_t mask,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei64(vbool32_t mask,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei64(vbool16_t mask,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei64(vbool8_t mask,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei64(vbool64_t mask,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei64(vbool32_t mask,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei64(vbool16_t mask,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei64(vbool8_t mask,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei64(vbool64_t mask,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei64(vbool32_t mask,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei64(vbool16_t mask,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei64(vbool8_t mask,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64(vbool64_t mask,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64(vbool32_t mask,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64(vbool16_t mask,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei64(vbool8_t mask,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64(vbool64_t mask,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64(vbool32_t mask,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei64(vbool16_t mask,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei64(vbool8_t mask,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64(vbool64_t mask,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei64(vbool32_t mask,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei64(vbool16_t mask,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei64(vbool8_t mask,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei64(vbool64_t mask,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei64(vbool32_t mask,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei64(vbool16_t mask,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei64(vbool8_t mask,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64(vbool64_t mask,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64(vbool32_t mask,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64(vbool16_t mask,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64(vbool8_t mask,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64(vbool64_t mask,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64(vbool32_t mask,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64(vbool16_t mask,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64(vbool8_t mask,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64-2.C
new file mode 100644
index 0000000..ad783a3
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64-2.C
@@ -0,0 +1,518 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei64(const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei64(const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei64(const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei64(const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei64(const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei64(const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei64(const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei64(const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei64(const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei64(const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei64(const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei64(const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei64(const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei64(const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei64(const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei64(const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64(const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64(const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64(const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei64(const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64(const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64(const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei64(const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei64(const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64(const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei64(const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei64(const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei64(const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei64(const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei64(const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei64(const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei64(const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64(const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64(const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64(const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64(const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64(const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64(const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64(const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64(const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,31);
+}
+
+
+vint8mf8_t test___riscv_vluxei64(vbool64_t mask,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei64(vbool32_t mask,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei64(vbool16_t mask,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei64(vbool8_t mask,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei64(vbool64_t mask,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei64(vbool32_t mask,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei64(vbool16_t mask,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei64(vbool8_t mask,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei64(vbool64_t mask,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei64(vbool32_t mask,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei64(vbool16_t mask,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei64(vbool8_t mask,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei64(vbool64_t mask,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei64(vbool32_t mask,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei64(vbool16_t mask,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei64(vbool8_t mask,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64(vbool64_t mask,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64(vbool32_t mask,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64(vbool16_t mask,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei64(vbool8_t mask,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64(vbool64_t mask,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64(vbool32_t mask,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei64(vbool16_t mask,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei64(vbool8_t mask,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64(vbool64_t mask,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei64(vbool32_t mask,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei64(vbool16_t mask,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei64(vbool8_t mask,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei64(vbool64_t mask,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei64(vbool32_t mask,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei64(vbool16_t mask,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei64(vbool8_t mask,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64(vbool64_t mask,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64(vbool32_t mask,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64(vbool16_t mask,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64(vbool8_t mask,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64(vbool64_t mask,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64(vbool32_t mask,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64(vbool16_t mask,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64(vbool8_t mask,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64-3.C
new file mode 100644
index 0000000..7fd7963
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64-3.C
@@ -0,0 +1,518 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei64(const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei64(const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei64(const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei64(const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei64(const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei64(const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei64(const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei64(const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei64(const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei64(const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei64(const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei64(const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei64(const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei64(const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei64(const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei64(const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64(const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64(const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64(const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei64(const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64(const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64(const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei64(const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei64(const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64(const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei64(const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei64(const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei64(const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei64(const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei64(const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei64(const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei64(const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64(const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64(const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64(const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64(const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64(const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64(const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64(const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64(const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(base,bindex,32);
+}
+
+
+vint8mf8_t test___riscv_vluxei64(vbool64_t mask,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei64(vbool32_t mask,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei64(vbool16_t mask,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei64(vbool8_t mask,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei64(vbool64_t mask,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei64(vbool32_t mask,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei64(vbool16_t mask,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei64(vbool8_t mask,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei64(vbool64_t mask,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei64(vbool32_t mask,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei64(vbool16_t mask,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei64(vbool8_t mask,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei64(vbool64_t mask,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei64(vbool32_t mask,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei64(vbool16_t mask,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei64(vbool8_t mask,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64(vbool64_t mask,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64(vbool32_t mask,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64(vbool16_t mask,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei64(vbool8_t mask,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64(vbool64_t mask,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64(vbool32_t mask,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei64(vbool16_t mask,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei64(vbool8_t mask,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64(vbool64_t mask,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei64(vbool32_t mask,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei64(vbool16_t mask,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei64(vbool8_t mask,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei64(vbool64_t mask,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei64(vbool32_t mask,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei64(vbool16_t mask,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei64(vbool8_t mask,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64(vbool64_t mask,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64(vbool32_t mask,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64(vbool16_t mask,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64(vbool8_t mask,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64(vbool64_t mask,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64(vbool32_t mask,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64(vbool16_t mask,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64(vbool8_t mask,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64(mask,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_mu-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_mu-1.C
new file mode 100644
index 0000000..7bf8ee8
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_mu-1.C
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei64_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei64_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei64_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei64_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei64_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei64_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei64_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei64_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei64_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei64_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei64_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei64_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei64_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei64_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei64_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei64_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei64_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei64_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei64_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei64_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei64_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei64_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei64_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei64_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei64_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei64_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_mu-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_mu-2.C
new file mode 100644
index 0000000..6cd43ad
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_mu-2.C
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei64_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei64_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei64_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei64_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei64_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei64_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei64_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei64_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei64_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei64_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei64_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei64_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei64_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei64_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei64_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei64_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei64_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei64_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei64_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei64_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei64_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei64_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei64_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei64_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei64_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei64_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_mu-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_mu-3.C
new file mode 100644
index 0000000..3f907d7
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_mu-3.C
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei64_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei64_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei64_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei64_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei64_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei64_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei64_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei64_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei64_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei64_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei64_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei64_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei64_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei64_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei64_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei64_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei64_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei64_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei64_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei64_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei64_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei64_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei64_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei64_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei64_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei64_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_mu(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_tu-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_tu-1.C
new file mode 100644
index 0000000..4a65737
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_tu-1.C
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei64_tu(vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei64_tu(vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei64_tu(vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei64_tu(vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei64_tu(vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei64_tu(vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei64_tu(vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei64_tu(vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei64_tu(vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei64_tu(vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei64_tu(vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei64_tu(vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei64_tu(vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei64_tu(vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei64_tu(vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei64_tu(vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64_tu(vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64_tu(vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64_tu(vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei64_tu(vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64_tu(vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64_tu(vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei64_tu(vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei64_tu(vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64_tu(vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei64_tu(vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei64_tu(vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei64_tu(vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei64_tu(vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei64_tu(vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei64_tu(vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei64_tu(vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64_tu(vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64_tu(vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64_tu(vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64_tu(vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64_tu(vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64_tu(vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64_tu(vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64_tu(vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_tu-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_tu-2.C
new file mode 100644
index 0000000..175b572
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_tu-2.C
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei64_tu(vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei64_tu(vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei64_tu(vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei64_tu(vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei64_tu(vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei64_tu(vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei64_tu(vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei64_tu(vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei64_tu(vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei64_tu(vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei64_tu(vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei64_tu(vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei64_tu(vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei64_tu(vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei64_tu(vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei64_tu(vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64_tu(vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64_tu(vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64_tu(vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei64_tu(vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64_tu(vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64_tu(vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei64_tu(vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei64_tu(vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64_tu(vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei64_tu(vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei64_tu(vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei64_tu(vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei64_tu(vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei64_tu(vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei64_tu(vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei64_tu(vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64_tu(vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64_tu(vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64_tu(vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64_tu(vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64_tu(vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64_tu(vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64_tu(vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64_tu(vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_tu-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_tu-3.C
new file mode 100644
index 0000000..a8d69df
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_tu-3.C
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei64_tu(vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei64_tu(vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei64_tu(vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei64_tu(vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei64_tu(vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei64_tu(vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei64_tu(vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei64_tu(vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei64_tu(vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei64_tu(vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei64_tu(vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei64_tu(vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei64_tu(vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei64_tu(vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei64_tu(vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei64_tu(vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64_tu(vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64_tu(vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64_tu(vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei64_tu(vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64_tu(vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64_tu(vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei64_tu(vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei64_tu(vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64_tu(vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei64_tu(vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei64_tu(vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei64_tu(vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei64_tu(vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei64_tu(vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei64_tu(vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei64_tu(vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64_tu(vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64_tu(vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64_tu(vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64_tu(vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64_tu(vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64_tu(vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64_tu(vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64_tu(vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tu(merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_tum-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_tum-1.C
new file mode 100644
index 0000000..652a9c7
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_tum-1.C
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei64_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei64_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei64_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei64_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei64_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei64_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei64_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei64_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei64_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei64_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei64_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei64_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei64_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei64_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei64_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei64_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei64_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei64_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei64_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei64_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei64_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei64_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei64_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei64_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei64_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei64_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_tum-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_tum-2.C
new file mode 100644
index 0000000..3ad56e8
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_tum-2.C
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei64_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei64_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei64_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei64_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei64_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei64_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei64_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei64_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei64_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei64_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei64_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei64_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei64_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei64_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei64_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei64_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei64_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei64_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei64_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei64_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei64_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei64_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei64_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei64_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei64_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei64_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_tum-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_tum-3.C
new file mode 100644
index 0000000..8ccbb17
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_tum-3.C
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei64_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei64_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei64_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei64_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei64_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei64_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei64_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei64_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei64_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei64_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei64_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei64_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei64_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei64_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei64_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei64_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei64_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei64_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei64_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei64_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei64_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei64_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei64_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei64_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei64_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei64_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tum(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_tumu-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_tumu-1.C
new file mode 100644
index 0000000..62d1106
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_tumu-1.C
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei64_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei64_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei64_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei64_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei64_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei64_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei64_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei64_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei64_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei64_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei64_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei64_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei64_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei64_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei64_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei64_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei64_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei64_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei64_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei64_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei64_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei64_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei64_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei64_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei64_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei64_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_tumu-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_tumu-2.C
new file mode 100644
index 0000000..0b6af97
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_tumu-2.C
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei64_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei64_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei64_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei64_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei64_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei64_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei64_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei64_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei64_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei64_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei64_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei64_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei64_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei64_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei64_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei64_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei64_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei64_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei64_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei64_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei64_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei64_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei64_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei64_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei64_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei64_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_tumu-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_tumu-3.C
new file mode 100644
index 0000000..a7226fb
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei64_tumu-3.C
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei64_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei64_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei64_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei64_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei64_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei64_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei64_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei64_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei64_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei64_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei64_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei64_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei64_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei64_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei64_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei64_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei64_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei64_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei64_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei64_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei64_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei64_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei64_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei64_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei64_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei64_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_tumu(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8-1.C
new file mode 100644
index 0000000..8056d19
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8-1.C
@@ -0,0 +1,686 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei8(const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei8(const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei8(const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei8(const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei8(const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vluxei8(const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vint8m8_t test___riscv_vluxei8(const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei8(const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei8(const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei8(const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei8(const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei8(const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vluxei8(const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei8(const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei8(const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei8(const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei8(const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei8(const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei8(const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei8(const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei8(const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei8(const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8(const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8(const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8(const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei8(const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei8(const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vluxei8(const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vuint8m8_t test___riscv_vluxei8(const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8(const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8(const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei8(const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei8(const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei8(const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vluxei8(const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8(const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei8(const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei8(const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei8(const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei8(const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei8(const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei8(const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei8(const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei8(const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8(const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8(const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8(const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8(const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8(const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8(const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8(const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8(const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8(const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,vl);
+}
+
+
+vint8mf8_t test___riscv_vluxei8(vbool64_t mask,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei8(vbool32_t mask,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei8(vbool16_t mask,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei8(vbool8_t mask,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei8(vbool4_t mask,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vluxei8(vbool2_t mask,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vint8m8_t test___riscv_vluxei8(vbool1_t mask,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei8(vbool64_t mask,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei8(vbool32_t mask,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei8(vbool16_t mask,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei8(vbool8_t mask,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei8(vbool4_t mask,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vluxei8(vbool2_t mask,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei8(vbool64_t mask,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei8(vbool32_t mask,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei8(vbool16_t mask,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei8(vbool8_t mask,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei8(vbool4_t mask,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei8(vbool64_t mask,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei8(vbool32_t mask,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei8(vbool16_t mask,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei8(vbool8_t mask,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8(vbool64_t mask,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8(vbool32_t mask,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8(vbool16_t mask,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei8(vbool8_t mask,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei8(vbool4_t mask,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vluxei8(vbool2_t mask,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vuint8m8_t test___riscv_vluxei8(vbool1_t mask,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8(vbool64_t mask,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8(vbool32_t mask,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei8(vbool16_t mask,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei8(vbool8_t mask,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei8(vbool4_t mask,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vluxei8(vbool2_t mask,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8(vbool64_t mask,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei8(vbool32_t mask,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei8(vbool16_t mask,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei8(vbool8_t mask,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei8(vbool4_t mask,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei8(vbool64_t mask,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei8(vbool32_t mask,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei8(vbool16_t mask,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei8(vbool8_t mask,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8(vbool64_t mask,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8(vbool32_t mask,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8(vbool16_t mask,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8(vbool8_t mask,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8(vbool4_t mask,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8(vbool64_t mask,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8(vbool32_t mask,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8(vbool16_t mask,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8(vbool8_t mask,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8-2.C
new file mode 100644
index 0000000..eef7eab
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8-2.C
@@ -0,0 +1,686 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei8(const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei8(const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei8(const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei8(const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei8(const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vluxei8(const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vint8m8_t test___riscv_vluxei8(const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei8(const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei8(const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei8(const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei8(const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei8(const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vluxei8(const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei8(const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei8(const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei8(const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei8(const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei8(const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei8(const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei8(const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei8(const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei8(const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8(const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8(const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8(const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei8(const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei8(const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vluxei8(const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vuint8m8_t test___riscv_vluxei8(const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8(const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8(const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei8(const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei8(const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei8(const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vluxei8(const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8(const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei8(const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei8(const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei8(const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei8(const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei8(const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei8(const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei8(const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei8(const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8(const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8(const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8(const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8(const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8(const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8(const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8(const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8(const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8(const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,31);
+}
+
+
+vint8mf8_t test___riscv_vluxei8(vbool64_t mask,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei8(vbool32_t mask,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei8(vbool16_t mask,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei8(vbool8_t mask,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei8(vbool4_t mask,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vluxei8(vbool2_t mask,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vint8m8_t test___riscv_vluxei8(vbool1_t mask,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei8(vbool64_t mask,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei8(vbool32_t mask,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei8(vbool16_t mask,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei8(vbool8_t mask,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei8(vbool4_t mask,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vluxei8(vbool2_t mask,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei8(vbool64_t mask,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei8(vbool32_t mask,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei8(vbool16_t mask,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei8(vbool8_t mask,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei8(vbool4_t mask,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei8(vbool64_t mask,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei8(vbool32_t mask,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei8(vbool16_t mask,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei8(vbool8_t mask,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8(vbool64_t mask,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8(vbool32_t mask,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8(vbool16_t mask,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei8(vbool8_t mask,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei8(vbool4_t mask,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vluxei8(vbool2_t mask,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vuint8m8_t test___riscv_vluxei8(vbool1_t mask,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8(vbool64_t mask,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8(vbool32_t mask,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei8(vbool16_t mask,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei8(vbool8_t mask,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei8(vbool4_t mask,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vluxei8(vbool2_t mask,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8(vbool64_t mask,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei8(vbool32_t mask,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei8(vbool16_t mask,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei8(vbool8_t mask,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei8(vbool4_t mask,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei8(vbool64_t mask,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei8(vbool32_t mask,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei8(vbool16_t mask,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei8(vbool8_t mask,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8(vbool64_t mask,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8(vbool32_t mask,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8(vbool16_t mask,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8(vbool8_t mask,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8(vbool4_t mask,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8(vbool64_t mask,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8(vbool32_t mask,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8(vbool16_t mask,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8(vbool8_t mask,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8-3.C
new file mode 100644
index 0000000..b159f56
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8-3.C
@@ -0,0 +1,686 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei8(const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei8(const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei8(const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei8(const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei8(const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vluxei8(const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vint8m8_t test___riscv_vluxei8(const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei8(const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei8(const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei8(const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei8(const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei8(const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vluxei8(const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei8(const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei8(const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei8(const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei8(const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei8(const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei8(const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei8(const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei8(const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei8(const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8(const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8(const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8(const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei8(const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei8(const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vluxei8(const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vuint8m8_t test___riscv_vluxei8(const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8(const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8(const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei8(const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei8(const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei8(const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vluxei8(const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8(const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei8(const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei8(const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei8(const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei8(const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei8(const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei8(const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei8(const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei8(const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8(const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8(const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8(const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8(const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8(const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8(const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8(const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8(const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8(const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(base,bindex,32);
+}
+
+
+vint8mf8_t test___riscv_vluxei8(vbool64_t mask,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei8(vbool32_t mask,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei8(vbool16_t mask,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei8(vbool8_t mask,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei8(vbool4_t mask,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vluxei8(vbool2_t mask,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vint8m8_t test___riscv_vluxei8(vbool1_t mask,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei8(vbool64_t mask,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei8(vbool32_t mask,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei8(vbool16_t mask,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei8(vbool8_t mask,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei8(vbool4_t mask,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vluxei8(vbool2_t mask,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei8(vbool64_t mask,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei8(vbool32_t mask,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei8(vbool16_t mask,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei8(vbool8_t mask,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei8(vbool4_t mask,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei8(vbool64_t mask,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei8(vbool32_t mask,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei8(vbool16_t mask,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei8(vbool8_t mask,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8(vbool64_t mask,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8(vbool32_t mask,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8(vbool16_t mask,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei8(vbool8_t mask,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei8(vbool4_t mask,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vluxei8(vbool2_t mask,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vuint8m8_t test___riscv_vluxei8(vbool1_t mask,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8(vbool64_t mask,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8(vbool32_t mask,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei8(vbool16_t mask,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei8(vbool8_t mask,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei8(vbool4_t mask,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vluxei8(vbool2_t mask,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8(vbool64_t mask,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei8(vbool32_t mask,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei8(vbool16_t mask,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei8(vbool8_t mask,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei8(vbool4_t mask,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei8(vbool64_t mask,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei8(vbool32_t mask,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei8(vbool16_t mask,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei8(vbool8_t mask,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8(vbool64_t mask,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8(vbool32_t mask,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8(vbool16_t mask,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8(vbool8_t mask,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8(vbool4_t mask,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8(vbool64_t mask,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8(vbool32_t mask,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8(vbool16_t mask,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8(vbool8_t mask,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8(mask,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_mu-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_mu-1.C
new file mode 100644
index 0000000..a8876d2
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_mu-1.C
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei8_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei8_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei8_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei8_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei8_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vluxei8_mu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m8_t test___riscv_vluxei8_mu(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei8_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei8_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei8_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei8_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei8_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vluxei8_mu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei8_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei8_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei8_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei8_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei8_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei8_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei8_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei8_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei8_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei8_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei8_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vluxei8_mu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m8_t test___riscv_vluxei8_mu(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei8_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei8_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei8_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vluxei8_mu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei8_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei8_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei8_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei8_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei8_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei8_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei8_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei8_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_mu-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_mu-2.C
new file mode 100644
index 0000000..3dc1fa7
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_mu-2.C
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei8_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei8_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei8_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei8_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei8_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vluxei8_mu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m8_t test___riscv_vluxei8_mu(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei8_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei8_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei8_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei8_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei8_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vluxei8_mu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei8_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei8_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei8_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei8_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei8_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei8_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei8_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei8_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei8_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei8_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei8_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vluxei8_mu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m8_t test___riscv_vluxei8_mu(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei8_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei8_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei8_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vluxei8_mu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei8_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei8_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei8_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei8_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei8_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei8_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei8_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei8_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_mu-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_mu-3.C
new file mode 100644
index 0000000..3a7327d
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_mu-3.C
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei8_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei8_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei8_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei8_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei8_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vluxei8_mu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m8_t test___riscv_vluxei8_mu(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei8_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei8_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei8_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei8_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei8_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vluxei8_mu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei8_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei8_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei8_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei8_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei8_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei8_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei8_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei8_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei8_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei8_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei8_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vluxei8_mu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m8_t test___riscv_vluxei8_mu(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei8_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei8_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei8_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vluxei8_mu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei8_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei8_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei8_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei8_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei8_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei8_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei8_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei8_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_mu(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_tu-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_tu-1.C
new file mode 100644
index 0000000..1b8e19c
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_tu-1.C
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei8_tu(vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei8_tu(vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei8_tu(vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei8_tu(vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei8_tu(vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vluxei8_tu(vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint8m8_t test___riscv_vluxei8_tu(vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei8_tu(vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei8_tu(vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei8_tu(vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei8_tu(vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei8_tu(vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vluxei8_tu(vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei8_tu(vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei8_tu(vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei8_tu(vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei8_tu(vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei8_tu(vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei8_tu(vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei8_tu(vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei8_tu(vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei8_tu(vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8_tu(vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8_tu(vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8_tu(vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei8_tu(vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei8_tu(vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vluxei8_tu(vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m8_t test___riscv_vluxei8_tu(vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8_tu(vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8_tu(vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei8_tu(vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei8_tu(vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei8_tu(vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vluxei8_tu(vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8_tu(vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei8_tu(vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei8_tu(vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei8_tu(vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei8_tu(vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei8_tu(vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei8_tu(vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei8_tu(vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei8_tu(vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8_tu(vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8_tu(vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8_tu(vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8_tu(vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8_tu(vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8_tu(vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8_tu(vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8_tu(vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8_tu(vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_tu-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_tu-2.C
new file mode 100644
index 0000000..aa82fc3
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_tu-2.C
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei8_tu(vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei8_tu(vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei8_tu(vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei8_tu(vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei8_tu(vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vluxei8_tu(vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vint8m8_t test___riscv_vluxei8_tu(vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei8_tu(vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei8_tu(vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei8_tu(vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei8_tu(vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei8_tu(vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vluxei8_tu(vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei8_tu(vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei8_tu(vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei8_tu(vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei8_tu(vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei8_tu(vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei8_tu(vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei8_tu(vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei8_tu(vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei8_tu(vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8_tu(vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8_tu(vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8_tu(vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei8_tu(vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei8_tu(vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vluxei8_tu(vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint8m8_t test___riscv_vluxei8_tu(vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8_tu(vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8_tu(vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei8_tu(vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei8_tu(vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei8_tu(vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vluxei8_tu(vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8_tu(vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei8_tu(vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei8_tu(vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei8_tu(vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei8_tu(vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei8_tu(vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei8_tu(vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei8_tu(vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei8_tu(vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8_tu(vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8_tu(vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8_tu(vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8_tu(vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8_tu(vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8_tu(vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8_tu(vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8_tu(vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8_tu(vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_tu-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_tu-3.C
new file mode 100644
index 0000000..59ed378
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_tu-3.C
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei8_tu(vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei8_tu(vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei8_tu(vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei8_tu(vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei8_tu(vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vluxei8_tu(vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vint8m8_t test___riscv_vluxei8_tu(vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei8_tu(vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei8_tu(vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei8_tu(vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei8_tu(vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei8_tu(vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vluxei8_tu(vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei8_tu(vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei8_tu(vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei8_tu(vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei8_tu(vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei8_tu(vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei8_tu(vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei8_tu(vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei8_tu(vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei8_tu(vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8_tu(vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8_tu(vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8_tu(vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei8_tu(vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei8_tu(vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vluxei8_tu(vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint8m8_t test___riscv_vluxei8_tu(vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8_tu(vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8_tu(vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei8_tu(vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei8_tu(vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei8_tu(vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vluxei8_tu(vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8_tu(vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei8_tu(vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei8_tu(vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei8_tu(vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei8_tu(vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei8_tu(vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei8_tu(vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei8_tu(vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei8_tu(vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8_tu(vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8_tu(vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8_tu(vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8_tu(vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8_tu(vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8_tu(vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8_tu(vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8_tu(vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8_tu(vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tu(merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_tum-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_tum-1.C
new file mode 100644
index 0000000..0c1fb63
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_tum-1.C
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei8_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei8_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei8_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei8_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei8_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vluxei8_tum(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m8_t test___riscv_vluxei8_tum(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei8_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei8_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei8_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei8_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei8_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vluxei8_tum(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei8_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei8_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei8_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei8_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei8_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei8_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei8_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei8_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei8_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei8_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei8_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vluxei8_tum(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m8_t test___riscv_vluxei8_tum(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei8_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei8_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei8_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vluxei8_tum(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei8_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei8_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei8_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei8_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei8_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei8_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei8_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei8_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_tum-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_tum-2.C
new file mode 100644
index 0000000..a6c8865
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_tum-2.C
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei8_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei8_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei8_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei8_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei8_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vluxei8_tum(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m8_t test___riscv_vluxei8_tum(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei8_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei8_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei8_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei8_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei8_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vluxei8_tum(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei8_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei8_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei8_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei8_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei8_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei8_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei8_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei8_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei8_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei8_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei8_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vluxei8_tum(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m8_t test___riscv_vluxei8_tum(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei8_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei8_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei8_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vluxei8_tum(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei8_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei8_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei8_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei8_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei8_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei8_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei8_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei8_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_tum-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_tum-3.C
new file mode 100644
index 0000000..02923d7
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_tum-3.C
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei8_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei8_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei8_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei8_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei8_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vluxei8_tum(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m8_t test___riscv_vluxei8_tum(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei8_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei8_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei8_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei8_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei8_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vluxei8_tum(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei8_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei8_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei8_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei8_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei8_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei8_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei8_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei8_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei8_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei8_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei8_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vluxei8_tum(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m8_t test___riscv_vluxei8_tum(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei8_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei8_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei8_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vluxei8_tum(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei8_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei8_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei8_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei8_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei8_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei8_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei8_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei8_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tum(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_tumu-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_tumu-1.C
new file mode 100644
index 0000000..ff71730
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_tumu-1.C
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei8_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei8_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei8_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei8_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei8_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vluxei8_tumu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m8_t test___riscv_vluxei8_tumu(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei8_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei8_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei8_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei8_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei8_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vluxei8_tumu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei8_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei8_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei8_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei8_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei8_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei8_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei8_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei8_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei8_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei8_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei8_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vluxei8_tumu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m8_t test___riscv_vluxei8_tumu(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei8_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei8_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei8_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vluxei8_tumu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei8_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei8_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei8_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei8_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei8_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei8_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei8_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei8_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_tumu-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_tumu-2.C
new file mode 100644
index 0000000..c90bc7e
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_tumu-2.C
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei8_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei8_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei8_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei8_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei8_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vluxei8_tumu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m8_t test___riscv_vluxei8_tumu(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei8_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei8_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei8_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei8_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei8_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vluxei8_tumu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei8_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei8_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei8_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei8_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei8_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei8_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei8_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei8_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei8_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei8_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei8_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vluxei8_tumu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m8_t test___riscv_vluxei8_tumu(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei8_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei8_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei8_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vluxei8_tumu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei8_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei8_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei8_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei8_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei8_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei8_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei8_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei8_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_tumu-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_tumu-3.C
new file mode 100644
index 0000000..7380f41
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vluxei8_tumu-3.C
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei8_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei8_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei8_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei8_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei8_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vluxei8_tumu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m8_t test___riscv_vluxei8_tumu(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei8_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei8_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei8_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei8_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei8_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vluxei8_tumu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei8_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei8_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei8_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei8_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei8_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei8_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei8_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei8_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei8_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei8_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei8_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vluxei8_tumu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m8_t test___riscv_vluxei8_tumu(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei8_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei8_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei8_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vluxei8_tumu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei8_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei8_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei8_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei8_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei8_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei8_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei8_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei8_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_tumu(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vse-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vse-1.C
new file mode 100644
index 0000000..8b969dc
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vse-1.C
@@ -0,0 +1,685 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void
+test___riscv_vse8(int8_t* base,vint8mf8_t value,size_t vl)
+{
+  __riscv_vse8(base,value,vl);
+}
+
+void
+test___riscv_vse8(int8_t* base,vint8mf4_t value,size_t vl)
+{
+  __riscv_vse8(base,value,vl);
+}
+
+void
+test___riscv_vse8(int8_t* base,vint8mf2_t value,size_t vl)
+{
+  __riscv_vse8(base,value,vl);
+}
+
+void
+test___riscv_vse8(int8_t* base,vint8m1_t value,size_t vl)
+{
+  __riscv_vse8(base,value,vl);
+}
+
+void
+test___riscv_vse8(int8_t* base,vint8m2_t value,size_t vl)
+{
+  __riscv_vse8(base,value,vl);
+}
+
+void
+test___riscv_vse8(int8_t* base,vint8m4_t value,size_t vl)
+{
+  __riscv_vse8(base,value,vl);
+}
+
+void
+test___riscv_vse8(int8_t* base,vint8m8_t value,size_t vl)
+{
+  __riscv_vse8(base,value,vl);
+}
+
+void
+test___riscv_vse8(uint8_t* base,vuint8mf8_t value,size_t vl)
+{
+  __riscv_vse8(base,value,vl);
+}
+
+void
+test___riscv_vse8(uint8_t* base,vuint8mf4_t value,size_t vl)
+{
+  __riscv_vse8(base,value,vl);
+}
+
+void
+test___riscv_vse8(uint8_t* base,vuint8mf2_t value,size_t vl)
+{
+  __riscv_vse8(base,value,vl);
+}
+
+void
+test___riscv_vse8(uint8_t* base,vuint8m1_t value,size_t vl)
+{
+  __riscv_vse8(base,value,vl);
+}
+
+void
+test___riscv_vse8(uint8_t* base,vuint8m2_t value,size_t vl)
+{
+  __riscv_vse8(base,value,vl);
+}
+
+void
+test___riscv_vse8(uint8_t* base,vuint8m4_t value,size_t vl)
+{
+  __riscv_vse8(base,value,vl);
+}
+
+void
+test___riscv_vse8(uint8_t* base,vuint8m8_t value,size_t vl)
+{
+  __riscv_vse8(base,value,vl);
+}
+
+void
+test___riscv_vse8(vbool64_t mask,int8_t* base,vint8mf8_t value,size_t vl)
+{
+  __riscv_vse8(mask,base,value,vl);
+}
+
+void
+test___riscv_vse8(vbool32_t mask,int8_t* base,vint8mf4_t value,size_t vl)
+{
+  __riscv_vse8(mask,base,value,vl);
+}
+
+void
+test___riscv_vse8(vbool16_t mask,int8_t* base,vint8mf2_t value,size_t vl)
+{
+  __riscv_vse8(mask,base,value,vl);
+}
+
+void
+test___riscv_vse8(vbool8_t mask,int8_t* base,vint8m1_t value,size_t vl)
+{
+  __riscv_vse8(mask,base,value,vl);
+}
+
+void
+test___riscv_vse8(vbool4_t mask,int8_t* base,vint8m2_t value,size_t vl)
+{
+  __riscv_vse8(mask,base,value,vl);
+}
+
+void
+test___riscv_vse8(vbool2_t mask,int8_t* base,vint8m4_t value,size_t vl)
+{
+  __riscv_vse8(mask,base,value,vl);
+}
+
+void
+test___riscv_vse8(vbool1_t mask,int8_t* base,vint8m8_t value,size_t vl)
+{
+  __riscv_vse8(mask,base,value,vl);
+}
+
+void
+test___riscv_vse8(vbool64_t mask,uint8_t* base,vuint8mf8_t value,size_t vl)
+{
+  __riscv_vse8(mask,base,value,vl);
+}
+
+void
+test___riscv_vse8(vbool32_t mask,uint8_t* base,vuint8mf4_t value,size_t vl)
+{
+  __riscv_vse8(mask,base,value,vl);
+}
+
+void
+test___riscv_vse8(vbool16_t mask,uint8_t* base,vuint8mf2_t value,size_t vl)
+{
+  __riscv_vse8(mask,base,value,vl);
+}
+
+void
+test___riscv_vse8(vbool8_t mask,uint8_t* base,vuint8m1_t value,size_t vl)
+{
+  __riscv_vse8(mask,base,value,vl);
+}
+
+void
+test___riscv_vse8(vbool4_t mask,uint8_t* base,vuint8m2_t value,size_t vl)
+{
+  __riscv_vse8(mask,base,value,vl);
+}
+
+void
+test___riscv_vse8(vbool2_t mask,uint8_t* base,vuint8m4_t value,size_t vl)
+{
+  __riscv_vse8(mask,base,value,vl);
+}
+
+void
+test___riscv_vse8(vbool1_t mask,uint8_t* base,vuint8m8_t value,size_t vl)
+{
+  __riscv_vse8(mask,base,value,vl);
+}
+
+void
+test___riscv_vse16(int16_t* base,vint16mf4_t value,size_t vl)
+{
+  __riscv_vse16(base,value,vl);
+}
+
+void
+test___riscv_vse16(int16_t* base,vint16mf2_t value,size_t vl)
+{
+  __riscv_vse16(base,value,vl);
+}
+
+void
+test___riscv_vse16(int16_t* base,vint16m1_t value,size_t vl)
+{
+  __riscv_vse16(base,value,vl);
+}
+
+void
+test___riscv_vse16(int16_t* base,vint16m2_t value,size_t vl)
+{
+  __riscv_vse16(base,value,vl);
+}
+
+void
+test___riscv_vse16(int16_t* base,vint16m4_t value,size_t vl)
+{
+  __riscv_vse16(base,value,vl);
+}
+
+void
+test___riscv_vse16(int16_t* base,vint16m8_t value,size_t vl)
+{
+  __riscv_vse16(base,value,vl);
+}
+
+void
+test___riscv_vse16(uint16_t* base,vuint16mf4_t value,size_t vl)
+{
+  __riscv_vse16(base,value,vl);
+}
+
+void
+test___riscv_vse16(uint16_t* base,vuint16mf2_t value,size_t vl)
+{
+  __riscv_vse16(base,value,vl);
+}
+
+void
+test___riscv_vse16(uint16_t* base,vuint16m1_t value,size_t vl)
+{
+  __riscv_vse16(base,value,vl);
+}
+
+void
+test___riscv_vse16(uint16_t* base,vuint16m2_t value,size_t vl)
+{
+  __riscv_vse16(base,value,vl);
+}
+
+void
+test___riscv_vse16(uint16_t* base,vuint16m4_t value,size_t vl)
+{
+  __riscv_vse16(base,value,vl);
+}
+
+void
+test___riscv_vse16(uint16_t* base,vuint16m8_t value,size_t vl)
+{
+  __riscv_vse16(base,value,vl);
+}
+
+void
+test___riscv_vse16(vbool64_t mask,int16_t* base,vint16mf4_t value,size_t vl)
+{
+  __riscv_vse16(mask,base,value,vl);
+}
+
+void
+test___riscv_vse16(vbool32_t mask,int16_t* base,vint16mf2_t value,size_t vl)
+{
+  __riscv_vse16(mask,base,value,vl);
+}
+
+void
+test___riscv_vse16(vbool16_t mask,int16_t* base,vint16m1_t value,size_t vl)
+{
+  __riscv_vse16(mask,base,value,vl);
+}
+
+void
+test___riscv_vse16(vbool8_t mask,int16_t* base,vint16m2_t value,size_t vl)
+{
+  __riscv_vse16(mask,base,value,vl);
+}
+
+void
+test___riscv_vse16(vbool4_t mask,int16_t* base,vint16m4_t value,size_t vl)
+{
+  __riscv_vse16(mask,base,value,vl);
+}
+
+void
+test___riscv_vse16(vbool2_t mask,int16_t* base,vint16m8_t value,size_t vl)
+{
+  __riscv_vse16(mask,base,value,vl);
+}
+
+void
+test___riscv_vse16(vbool64_t mask,uint16_t* base,vuint16mf4_t value,size_t vl)
+{
+  __riscv_vse16(mask,base,value,vl);
+}
+
+void
+test___riscv_vse16(vbool32_t mask,uint16_t* base,vuint16mf2_t value,size_t vl)
+{
+  __riscv_vse16(mask,base,value,vl);
+}
+
+void
+test___riscv_vse16(vbool16_t mask,uint16_t* base,vuint16m1_t value,size_t vl)
+{
+  __riscv_vse16(mask,base,value,vl);
+}
+
+void
+test___riscv_vse16(vbool8_t mask,uint16_t* base,vuint16m2_t value,size_t vl)
+{
+  __riscv_vse16(mask,base,value,vl);
+}
+
+void
+test___riscv_vse16(vbool4_t mask,uint16_t* base,vuint16m4_t value,size_t vl)
+{
+  __riscv_vse16(mask,base,value,vl);
+}
+
+void
+test___riscv_vse16(vbool2_t mask,uint16_t* base,vuint16m8_t value,size_t vl)
+{
+  __riscv_vse16(mask,base,value,vl);
+}
+
+void
+test___riscv_vse32(int32_t* base,vint32mf2_t value,size_t vl)
+{
+  __riscv_vse32(base,value,vl);
+}
+
+void
+test___riscv_vse32(int32_t* base,vint32m1_t value,size_t vl)
+{
+  __riscv_vse32(base,value,vl);
+}
+
+void
+test___riscv_vse32(int32_t* base,vint32m2_t value,size_t vl)
+{
+  __riscv_vse32(base,value,vl);
+}
+
+void
+test___riscv_vse32(int32_t* base,vint32m4_t value,size_t vl)
+{
+  __riscv_vse32(base,value,vl);
+}
+
+void
+test___riscv_vse32(int32_t* base,vint32m8_t value,size_t vl)
+{
+  __riscv_vse32(base,value,vl);
+}
+
+void
+test___riscv_vse32(uint32_t* base,vuint32mf2_t value,size_t vl)
+{
+  __riscv_vse32(base,value,vl);
+}
+
+void
+test___riscv_vse32(uint32_t* base,vuint32m1_t value,size_t vl)
+{
+  __riscv_vse32(base,value,vl);
+}
+
+void
+test___riscv_vse32(uint32_t* base,vuint32m2_t value,size_t vl)
+{
+  __riscv_vse32(base,value,vl);
+}
+
+void
+test___riscv_vse32(uint32_t* base,vuint32m4_t value,size_t vl)
+{
+  __riscv_vse32(base,value,vl);
+}
+
+void
+test___riscv_vse32(uint32_t* base,vuint32m8_t value,size_t vl)
+{
+  __riscv_vse32(base,value,vl);
+}
+
+void
+test___riscv_vse32(float* base,vfloat32mf2_t value,size_t vl)
+{
+  __riscv_vse32(base,value,vl);
+}
+
+void
+test___riscv_vse32(float* base,vfloat32m1_t value,size_t vl)
+{
+  __riscv_vse32(base,value,vl);
+}
+
+void
+test___riscv_vse32(float* base,vfloat32m2_t value,size_t vl)
+{
+  __riscv_vse32(base,value,vl);
+}
+
+void
+test___riscv_vse32(float* base,vfloat32m4_t value,size_t vl)
+{
+  __riscv_vse32(base,value,vl);
+}
+
+void
+test___riscv_vse32(float* base,vfloat32m8_t value,size_t vl)
+{
+  __riscv_vse32(base,value,vl);
+}
+
+void
+test___riscv_vse32(vbool64_t mask,int32_t* base,vint32mf2_t value,size_t vl)
+{
+  __riscv_vse32(mask,base,value,vl);
+}
+
+void
+test___riscv_vse32(vbool32_t mask,int32_t* base,vint32m1_t value,size_t vl)
+{
+  __riscv_vse32(mask,base,value,vl);
+}
+
+void
+test___riscv_vse32(vbool16_t mask,int32_t* base,vint32m2_t value,size_t vl)
+{
+  __riscv_vse32(mask,base,value,vl);
+}
+
+void
+test___riscv_vse32(vbool8_t mask,int32_t* base,vint32m4_t value,size_t vl)
+{
+  __riscv_vse32(mask,base,value,vl);
+}
+
+void
+test___riscv_vse32(vbool4_t mask,int32_t* base,vint32m8_t value,size_t vl)
+{
+  __riscv_vse32(mask,base,value,vl);
+}
+
+void
+test___riscv_vse32(vbool64_t mask,uint32_t* base,vuint32mf2_t value,size_t vl)
+{
+  __riscv_vse32(mask,base,value,vl);
+}
+
+void
+test___riscv_vse32(vbool32_t mask,uint32_t* base,vuint32m1_t value,size_t vl)
+{
+  __riscv_vse32(mask,base,value,vl);
+}
+
+void
+test___riscv_vse32(vbool16_t mask,uint32_t* base,vuint32m2_t value,size_t vl)
+{
+  __riscv_vse32(mask,base,value,vl);
+}
+
+void
+test___riscv_vse32(vbool8_t mask,uint32_t* base,vuint32m4_t value,size_t vl)
+{
+  __riscv_vse32(mask,base,value,vl);
+}
+
+void
+test___riscv_vse32(vbool4_t mask,uint32_t* base,vuint32m8_t value,size_t vl)
+{
+  __riscv_vse32(mask,base,value,vl);
+}
+
+void
+test___riscv_vse32(vbool64_t mask,float* base,vfloat32mf2_t value,size_t vl)
+{
+  __riscv_vse32(mask,base,value,vl);
+}
+
+void
+test___riscv_vse32(vbool32_t mask,float* base,vfloat32m1_t value,size_t vl)
+{
+  __riscv_vse32(mask,base,value,vl);
+}
+
+void
+test___riscv_vse32(vbool16_t mask,float* base,vfloat32m2_t value,size_t vl)
+{
+  __riscv_vse32(mask,base,value,vl);
+}
+
+void
+test___riscv_vse32(vbool8_t mask,float* base,vfloat32m4_t value,size_t vl)
+{
+  __riscv_vse32(mask,base,value,vl);
+}
+
+void
+test___riscv_vse32(vbool4_t mask,float* base,vfloat32m8_t value,size_t vl)
+{
+  __riscv_vse32(mask,base,value,vl);
+}
+
+void
+test___riscv_vse64(int64_t* base,vint64m1_t value,size_t vl)
+{
+  __riscv_vse64(base,value,vl);
+}
+
+void
+test___riscv_vse64(int64_t* base,vint64m2_t value,size_t vl)
+{
+  __riscv_vse64(base,value,vl);
+}
+
+void
+test___riscv_vse64(int64_t* base,vint64m4_t value,size_t vl)
+{
+  __riscv_vse64(base,value,vl);
+}
+
+void
+test___riscv_vse64(int64_t* base,vint64m8_t value,size_t vl)
+{
+  __riscv_vse64(base,value,vl);
+}
+
+void
+test___riscv_vse64(uint64_t* base,vuint64m1_t value,size_t vl)
+{
+  __riscv_vse64(base,value,vl);
+}
+
+void
+test___riscv_vse64(uint64_t* base,vuint64m2_t value,size_t vl)
+{
+  __riscv_vse64(base,value,vl);
+}
+
+void
+test___riscv_vse64(uint64_t* base,vuint64m4_t value,size_t vl)
+{
+  __riscv_vse64(base,value,vl);
+}
+
+void
+test___riscv_vse64(uint64_t* base,vuint64m8_t value,size_t vl)
+{
+  __riscv_vse64(base,value,vl);
+}
+
+void
+test___riscv_vse64(double* base,vfloat64m1_t value,size_t vl)
+{
+  __riscv_vse64(base,value,vl);
+}
+
+void
+test___riscv_vse64(double* base,vfloat64m2_t value,size_t vl)
+{
+  __riscv_vse64(base,value,vl);
+}
+
+void
+test___riscv_vse64(double* base,vfloat64m4_t value,size_t vl)
+{
+  __riscv_vse64(base,value,vl);
+}
+
+void
+test___riscv_vse64(double* base,vfloat64m8_t value,size_t vl)
+{
+  __riscv_vse64(base,value,vl);
+}
+
+void
+test___riscv_vse64(vbool64_t mask,int64_t* base,vint64m1_t value,size_t vl)
+{
+  __riscv_vse64(mask,base,value,vl);
+}
+
+void
+test___riscv_vse64(vbool32_t mask,int64_t* base,vint64m2_t value,size_t vl)
+{
+  __riscv_vse64(mask,base,value,vl);
+}
+
+void
+test___riscv_vse64(vbool16_t mask,int64_t* base,vint64m4_t value,size_t vl)
+{
+  __riscv_vse64(mask,base,value,vl);
+}
+
+void
+test___riscv_vse64(vbool8_t mask,int64_t* base,vint64m8_t value,size_t vl)
+{
+  __riscv_vse64(mask,base,value,vl);
+}
+
+void
+test___riscv_vse64(vbool64_t mask,uint64_t* base,vuint64m1_t value,size_t vl)
+{
+  __riscv_vse64(mask,base,value,vl);
+}
+
+void
+test___riscv_vse64(vbool32_t mask,uint64_t* base,vuint64m2_t value,size_t vl)
+{
+  __riscv_vse64(mask,base,value,vl);
+}
+
+void
+test___riscv_vse64(vbool16_t mask,uint64_t* base,vuint64m4_t value,size_t vl)
+{
+  __riscv_vse64(mask,base,value,vl);
+}
+
+void
+test___riscv_vse64(vbool8_t mask,uint64_t* base,vuint64m8_t value,size_t vl)
+{
+  __riscv_vse64(mask,base,value,vl);
+}
+
+void
+test___riscv_vse64(vbool64_t mask,double* base,vfloat64m1_t value,size_t vl)
+{
+  __riscv_vse64(mask,base,value,vl);
+}
+
+void
+test___riscv_vse64(vbool32_t mask,double* base,vfloat64m2_t value,size_t vl)
+{
+  __riscv_vse64(mask,base,value,vl);
+}
+
+void
+test___riscv_vse64(vbool16_t mask,double* base,vfloat64m4_t value,size_t vl)
+{
+  __riscv_vse64(mask,base,value,vl);
+}
+
+void
+test___riscv_vse64(vbool8_t mask,double* base,vfloat64m8_t value,size_t vl)
+{
+  __riscv_vse64(mask,base,value,vl);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vsm-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vsm-1.C
new file mode 100644
index 0000000..60656cc
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vsm-1.C
@@ -0,0 +1,40 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsm_v_b1_vl(uint8_t *base, vbool1_t value, size_t vl) {
+  __riscv_vsm(base, value, vl);
+}
+
+void test___riscv_vsm_v_b2_vl(uint8_t *base, vbool2_t value, size_t vl) {
+  __riscv_vsm(base, value, vl);
+}
+
+void test___riscv_vsm_v_b4_vl(uint8_t *base, vbool4_t value, size_t vl) {
+  __riscv_vsm(base, value, vl);
+}
+
+void test___riscv_vsm_v_b8_vl(uint8_t *base, vbool8_t value, size_t vl) {
+  __riscv_vsm(base, value, vl);
+}
+
+void test___riscv_vsm_v_b16_vl(uint8_t *base, vbool16_t value, size_t vl) {
+  __riscv_vsm(base, value, vl);
+}
+
+void test___riscv_vsm_v_b32_vl(uint8_t *base, vbool32_t value, size_t vl) {
+  __riscv_vsm(base, value, vl);
+}
+
+void test___riscv_vsm_v_b64_vl(uint8_t *base, vbool64_t value, size_t vl) {
+  __riscv_vsm(base, value, vl);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei16-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei16-1.C
new file mode 100644
index 0000000..4473707
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei16-1.C
@@ -0,0 +1,660 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei16(int8_t* base,vuint16mf4_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(int8_t* base,vuint16mf2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(int8_t* base,vuint16m1_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(int8_t* base,vuint16m2_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(int8_t* base,vuint16m4_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(int8_t* base,vuint16m8_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(int16_t* base,vuint16mf4_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(int16_t* base,vuint16mf2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(int16_t* base,vuint16m1_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(int16_t* base,vuint16m2_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(int16_t* base,vuint16m4_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(int16_t* base,vuint16m8_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(int32_t* base,vuint16mf4_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(int32_t* base,vuint16mf2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(int32_t* base,vuint16m1_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(int32_t* base,vuint16m2_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(int32_t* base,vuint16m4_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(int64_t* base,vuint16mf4_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(int64_t* base,vuint16mf2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(int64_t* base,vuint16m1_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(int64_t* base,vuint16m2_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(uint8_t* base,vuint16mf4_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(uint8_t* base,vuint16mf2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(uint8_t* base,vuint16m1_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(uint8_t* base,vuint16m2_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(uint8_t* base,vuint16m4_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(uint8_t* base,vuint16m8_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(uint16_t* base,vuint16mf4_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(uint16_t* base,vuint16mf2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(uint16_t* base,vuint16m1_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(uint16_t* base,vuint16m2_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(uint16_t* base,vuint16m4_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(uint16_t* base,vuint16m8_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(uint32_t* base,vuint16mf4_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(uint32_t* base,vuint16mf2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(uint32_t* base,vuint16m1_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(uint32_t* base,vuint16m2_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(uint32_t* base,vuint16m4_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(uint64_t* base,vuint16mf4_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(uint64_t* base,vuint16mf2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(uint64_t* base,vuint16m1_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(uint64_t* base,vuint16m2_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(float* base,vuint16mf4_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(float* base,vuint16mf2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(float* base,vuint16m1_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(float* base,vuint16m2_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(float* base,vuint16m4_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(double* base,vuint16mf4_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(double* base,vuint16mf2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(double* base,vuint16m1_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(double* base,vuint16m2_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool64_t mask,int8_t* base,vuint16mf4_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool32_t mask,int8_t* base,vuint16mf2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool16_t mask,int8_t* base,vuint16m1_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool8_t mask,int8_t* base,vuint16m2_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool4_t mask,int8_t* base,vuint16m4_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool2_t mask,int8_t* base,vuint16m8_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool64_t mask,int16_t* base,vuint16mf4_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool32_t mask,int16_t* base,vuint16mf2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool16_t mask,int16_t* base,vuint16m1_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool8_t mask,int16_t* base,vuint16m2_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool4_t mask,int16_t* base,vuint16m4_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool2_t mask,int16_t* base,vuint16m8_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool64_t mask,int32_t* base,vuint16mf4_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool32_t mask,int32_t* base,vuint16mf2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool16_t mask,int32_t* base,vuint16m1_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool8_t mask,int32_t* base,vuint16m2_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool4_t mask,int32_t* base,vuint16m4_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool64_t mask,int64_t* base,vuint16mf4_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool32_t mask,int64_t* base,vuint16mf2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool16_t mask,int64_t* base,vuint16m1_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool8_t mask,int64_t* base,vuint16m2_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool64_t mask,uint8_t* base,vuint16mf4_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool32_t mask,uint8_t* base,vuint16mf2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool16_t mask,uint8_t* base,vuint16m1_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool8_t mask,uint8_t* base,vuint16m2_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool4_t mask,uint8_t* base,vuint16m4_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool2_t mask,uint8_t* base,vuint16m8_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool64_t mask,uint16_t* base,vuint16mf4_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool32_t mask,uint16_t* base,vuint16mf2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool16_t mask,uint16_t* base,vuint16m1_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool8_t mask,uint16_t* base,vuint16m2_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool4_t mask,uint16_t* base,vuint16m4_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool2_t mask,uint16_t* base,vuint16m8_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool64_t mask,uint32_t* base,vuint16mf4_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool32_t mask,uint32_t* base,vuint16mf2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool16_t mask,uint32_t* base,vuint16m1_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool8_t mask,uint32_t* base,vuint16m2_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool4_t mask,uint32_t* base,vuint16m4_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool64_t mask,uint64_t* base,vuint16mf4_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool32_t mask,uint64_t* base,vuint16mf2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool16_t mask,uint64_t* base,vuint16m1_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool8_t mask,uint64_t* base,vuint16m2_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool64_t mask,float* base,vuint16mf4_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool32_t mask,float* base,vuint16mf2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool16_t mask,float* base,vuint16m1_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool8_t mask,float* base,vuint16m2_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool4_t mask,float* base,vuint16m4_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool64_t mask,double* base,vuint16mf4_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool32_t mask,double* base,vuint16mf2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool16_t mask,double* base,vuint16m1_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16(vbool8_t mask,double* base,vuint16m2_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei16-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei16-2.C
new file mode 100644
index 0000000..929f7cf
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei16-2.C
@@ -0,0 +1,660 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei16(int8_t* base,vuint16mf4_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(int8_t* base,vuint16mf2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(int8_t* base,vuint16m1_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(int8_t* base,vuint16m2_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(int8_t* base,vuint16m4_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(int8_t* base,vuint16m8_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(int16_t* base,vuint16mf4_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(int16_t* base,vuint16mf2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(int16_t* base,vuint16m1_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(int16_t* base,vuint16m2_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(int16_t* base,vuint16m4_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(int16_t* base,vuint16m8_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(int32_t* base,vuint16mf4_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(int32_t* base,vuint16mf2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(int32_t* base,vuint16m1_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(int32_t* base,vuint16m2_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(int32_t* base,vuint16m4_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(int64_t* base,vuint16mf4_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(int64_t* base,vuint16mf2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(int64_t* base,vuint16m1_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(int64_t* base,vuint16m2_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(uint8_t* base,vuint16mf4_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(uint8_t* base,vuint16mf2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(uint8_t* base,vuint16m1_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(uint8_t* base,vuint16m2_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(uint8_t* base,vuint16m4_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(uint8_t* base,vuint16m8_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(uint16_t* base,vuint16mf4_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(uint16_t* base,vuint16mf2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(uint16_t* base,vuint16m1_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(uint16_t* base,vuint16m2_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(uint16_t* base,vuint16m4_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(uint16_t* base,vuint16m8_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(uint32_t* base,vuint16mf4_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(uint32_t* base,vuint16mf2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(uint32_t* base,vuint16m1_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(uint32_t* base,vuint16m2_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(uint32_t* base,vuint16m4_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(uint64_t* base,vuint16mf4_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(uint64_t* base,vuint16mf2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(uint64_t* base,vuint16m1_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(uint64_t* base,vuint16m2_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(float* base,vuint16mf4_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(float* base,vuint16mf2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(float* base,vuint16m1_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(float* base,vuint16m2_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(float* base,vuint16m4_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(double* base,vuint16mf4_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(double* base,vuint16mf2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(double* base,vuint16m1_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(double* base,vuint16m2_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool64_t mask,int8_t* base,vuint16mf4_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool32_t mask,int8_t* base,vuint16mf2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool16_t mask,int8_t* base,vuint16m1_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool8_t mask,int8_t* base,vuint16m2_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool4_t mask,int8_t* base,vuint16m4_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool2_t mask,int8_t* base,vuint16m8_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool64_t mask,int16_t* base,vuint16mf4_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool32_t mask,int16_t* base,vuint16mf2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool16_t mask,int16_t* base,vuint16m1_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool8_t mask,int16_t* base,vuint16m2_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool4_t mask,int16_t* base,vuint16m4_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool2_t mask,int16_t* base,vuint16m8_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool64_t mask,int32_t* base,vuint16mf4_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool32_t mask,int32_t* base,vuint16mf2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool16_t mask,int32_t* base,vuint16m1_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool8_t mask,int32_t* base,vuint16m2_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool4_t mask,int32_t* base,vuint16m4_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool64_t mask,int64_t* base,vuint16mf4_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool32_t mask,int64_t* base,vuint16mf2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool16_t mask,int64_t* base,vuint16m1_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool8_t mask,int64_t* base,vuint16m2_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool64_t mask,uint8_t* base,vuint16mf4_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool32_t mask,uint8_t* base,vuint16mf2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool16_t mask,uint8_t* base,vuint16m1_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool8_t mask,uint8_t* base,vuint16m2_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool4_t mask,uint8_t* base,vuint16m4_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool2_t mask,uint8_t* base,vuint16m8_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool64_t mask,uint16_t* base,vuint16mf4_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool32_t mask,uint16_t* base,vuint16mf2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool16_t mask,uint16_t* base,vuint16m1_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool8_t mask,uint16_t* base,vuint16m2_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool4_t mask,uint16_t* base,vuint16m4_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool2_t mask,uint16_t* base,vuint16m8_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool64_t mask,uint32_t* base,vuint16mf4_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool32_t mask,uint32_t* base,vuint16mf2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool16_t mask,uint32_t* base,vuint16m1_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool8_t mask,uint32_t* base,vuint16m2_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool4_t mask,uint32_t* base,vuint16m4_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool64_t mask,uint64_t* base,vuint16mf4_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool32_t mask,uint64_t* base,vuint16mf2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool16_t mask,uint64_t* base,vuint16m1_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool8_t mask,uint64_t* base,vuint16m2_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool64_t mask,float* base,vuint16mf4_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool32_t mask,float* base,vuint16mf2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool16_t mask,float* base,vuint16m1_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool8_t mask,float* base,vuint16m2_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool4_t mask,float* base,vuint16m4_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool64_t mask,double* base,vuint16mf4_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool32_t mask,double* base,vuint16mf2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool16_t mask,double* base,vuint16m1_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16(vbool8_t mask,double* base,vuint16m2_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei16-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei16-3.C
new file mode 100644
index 0000000..e80368b
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei16-3.C
@@ -0,0 +1,660 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei16(int8_t* base,vuint16mf4_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(int8_t* base,vuint16mf2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(int8_t* base,vuint16m1_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(int8_t* base,vuint16m2_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(int8_t* base,vuint16m4_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(int8_t* base,vuint16m8_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(int16_t* base,vuint16mf4_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(int16_t* base,vuint16mf2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(int16_t* base,vuint16m1_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(int16_t* base,vuint16m2_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(int16_t* base,vuint16m4_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(int16_t* base,vuint16m8_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(int32_t* base,vuint16mf4_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(int32_t* base,vuint16mf2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(int32_t* base,vuint16m1_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(int32_t* base,vuint16m2_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(int32_t* base,vuint16m4_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(int64_t* base,vuint16mf4_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(int64_t* base,vuint16mf2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(int64_t* base,vuint16m1_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(int64_t* base,vuint16m2_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(uint8_t* base,vuint16mf4_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(uint8_t* base,vuint16mf2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(uint8_t* base,vuint16m1_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(uint8_t* base,vuint16m2_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(uint8_t* base,vuint16m4_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(uint8_t* base,vuint16m8_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(uint16_t* base,vuint16mf4_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(uint16_t* base,vuint16mf2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(uint16_t* base,vuint16m1_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(uint16_t* base,vuint16m2_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(uint16_t* base,vuint16m4_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(uint16_t* base,vuint16m8_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(uint32_t* base,vuint16mf4_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(uint32_t* base,vuint16mf2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(uint32_t* base,vuint16m1_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(uint32_t* base,vuint16m2_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(uint32_t* base,vuint16m4_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(uint64_t* base,vuint16mf4_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(uint64_t* base,vuint16mf2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(uint64_t* base,vuint16m1_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(uint64_t* base,vuint16m2_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(float* base,vuint16mf4_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(float* base,vuint16mf2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(float* base,vuint16m1_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(float* base,vuint16m2_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(float* base,vuint16m4_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(double* base,vuint16mf4_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(double* base,vuint16mf2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(double* base,vuint16m1_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(double* base,vuint16m2_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool64_t mask,int8_t* base,vuint16mf4_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool32_t mask,int8_t* base,vuint16mf2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool16_t mask,int8_t* base,vuint16m1_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool8_t mask,int8_t* base,vuint16m2_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool4_t mask,int8_t* base,vuint16m4_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool2_t mask,int8_t* base,vuint16m8_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool64_t mask,int16_t* base,vuint16mf4_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool32_t mask,int16_t* base,vuint16mf2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool16_t mask,int16_t* base,vuint16m1_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool8_t mask,int16_t* base,vuint16m2_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool4_t mask,int16_t* base,vuint16m4_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool2_t mask,int16_t* base,vuint16m8_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool64_t mask,int32_t* base,vuint16mf4_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool32_t mask,int32_t* base,vuint16mf2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool16_t mask,int32_t* base,vuint16m1_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool8_t mask,int32_t* base,vuint16m2_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool4_t mask,int32_t* base,vuint16m4_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool64_t mask,int64_t* base,vuint16mf4_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool32_t mask,int64_t* base,vuint16mf2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool16_t mask,int64_t* base,vuint16m1_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool8_t mask,int64_t* base,vuint16m2_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool64_t mask,uint8_t* base,vuint16mf4_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool32_t mask,uint8_t* base,vuint16mf2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool16_t mask,uint8_t* base,vuint16m1_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool8_t mask,uint8_t* base,vuint16m2_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool4_t mask,uint8_t* base,vuint16m4_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool2_t mask,uint8_t* base,vuint16m8_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool64_t mask,uint16_t* base,vuint16mf4_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool32_t mask,uint16_t* base,vuint16mf2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool16_t mask,uint16_t* base,vuint16m1_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool8_t mask,uint16_t* base,vuint16m2_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool4_t mask,uint16_t* base,vuint16m4_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool2_t mask,uint16_t* base,vuint16m8_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool64_t mask,uint32_t* base,vuint16mf4_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool32_t mask,uint32_t* base,vuint16mf2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool16_t mask,uint32_t* base,vuint16m1_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool8_t mask,uint32_t* base,vuint16m2_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool4_t mask,uint32_t* base,vuint16m4_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool64_t mask,uint64_t* base,vuint16mf4_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool32_t mask,uint64_t* base,vuint16mf2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool16_t mask,uint64_t* base,vuint16m1_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool8_t mask,uint64_t* base,vuint16m2_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool64_t mask,float* base,vuint16mf4_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool32_t mask,float* base,vuint16mf2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool16_t mask,float* base,vuint16m1_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool8_t mask,float* base,vuint16m2_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool4_t mask,float* base,vuint16m4_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool64_t mask,double* base,vuint16mf4_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool32_t mask,double* base,vuint16mf2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool16_t mask,double* base,vuint16m1_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16(vbool8_t mask,double* base,vuint16m2_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16(mask,base,bindex,value,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei32-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei32-1.C
new file mode 100644
index 0000000..3f39f88
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei32-1.C
@@ -0,0 +1,608 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei32(int8_t* base,vuint32mf2_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(int8_t* base,vuint32m1_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(int8_t* base,vuint32m2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(int8_t* base,vuint32m4_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(int8_t* base,vuint32m8_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(int16_t* base,vuint32mf2_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(int16_t* base,vuint32m1_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(int16_t* base,vuint32m2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(int16_t* base,vuint32m4_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(int16_t* base,vuint32m8_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(int32_t* base,vuint32mf2_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(int32_t* base,vuint32m1_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(int32_t* base,vuint32m2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(int32_t* base,vuint32m4_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(int32_t* base,vuint32m8_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(int64_t* base,vuint32mf2_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(int64_t* base,vuint32m1_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(int64_t* base,vuint32m2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(int64_t* base,vuint32m4_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(uint8_t* base,vuint32mf2_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(uint8_t* base,vuint32m1_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(uint8_t* base,vuint32m2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(uint8_t* base,vuint32m4_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(uint8_t* base,vuint32m8_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(uint16_t* base,vuint32mf2_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(uint16_t* base,vuint32m1_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(uint16_t* base,vuint32m2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(uint16_t* base,vuint32m4_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(uint16_t* base,vuint32m8_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(uint32_t* base,vuint32mf2_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(uint32_t* base,vuint32m1_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(uint32_t* base,vuint32m2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(uint32_t* base,vuint32m4_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(uint32_t* base,vuint32m8_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(uint64_t* base,vuint32mf2_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(uint64_t* base,vuint32m1_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(uint64_t* base,vuint32m2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(uint64_t* base,vuint32m4_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(float* base,vuint32mf2_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(float* base,vuint32m1_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(float* base,vuint32m2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(float* base,vuint32m4_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(float* base,vuint32m8_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(double* base,vuint32mf2_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(double* base,vuint32m1_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(double* base,vuint32m2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(double* base,vuint32m4_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool64_t mask,int8_t* base,vuint32mf2_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool32_t mask,int8_t* base,vuint32m1_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool16_t mask,int8_t* base,vuint32m2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool8_t mask,int8_t* base,vuint32m4_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool4_t mask,int8_t* base,vuint32m8_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool64_t mask,int16_t* base,vuint32mf2_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool32_t mask,int16_t* base,vuint32m1_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool16_t mask,int16_t* base,vuint32m2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool8_t mask,int16_t* base,vuint32m4_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool4_t mask,int16_t* base,vuint32m8_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool64_t mask,int32_t* base,vuint32mf2_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool32_t mask,int32_t* base,vuint32m1_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool16_t mask,int32_t* base,vuint32m2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool8_t mask,int32_t* base,vuint32m4_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool4_t mask,int32_t* base,vuint32m8_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool64_t mask,int64_t* base,vuint32mf2_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool32_t mask,int64_t* base,vuint32m1_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool16_t mask,int64_t* base,vuint32m2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool8_t mask,int64_t* base,vuint32m4_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool64_t mask,uint8_t* base,vuint32mf2_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool32_t mask,uint8_t* base,vuint32m1_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool16_t mask,uint8_t* base,vuint32m2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool8_t mask,uint8_t* base,vuint32m4_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool4_t mask,uint8_t* base,vuint32m8_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool64_t mask,uint16_t* base,vuint32mf2_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool32_t mask,uint16_t* base,vuint32m1_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool16_t mask,uint16_t* base,vuint32m2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool8_t mask,uint16_t* base,vuint32m4_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool4_t mask,uint16_t* base,vuint32m8_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool64_t mask,uint32_t* base,vuint32mf2_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool32_t mask,uint32_t* base,vuint32m1_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool16_t mask,uint32_t* base,vuint32m2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool8_t mask,uint32_t* base,vuint32m4_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool4_t mask,uint32_t* base,vuint32m8_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool64_t mask,uint64_t* base,vuint32mf2_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool32_t mask,uint64_t* base,vuint32m1_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool16_t mask,uint64_t* base,vuint32m2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool8_t mask,uint64_t* base,vuint32m4_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool64_t mask,float* base,vuint32mf2_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool32_t mask,float* base,vuint32m1_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool16_t mask,float* base,vuint32m2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool8_t mask,float* base,vuint32m4_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool4_t mask,float* base,vuint32m8_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool64_t mask,double* base,vuint32mf2_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool32_t mask,double* base,vuint32m1_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool16_t mask,double* base,vuint32m2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32(vbool8_t mask,double* base,vuint32m4_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei32-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei32-2.C
new file mode 100644
index 0000000..d0b6b51
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei32-2.C
@@ -0,0 +1,608 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei32(int8_t* base,vuint32mf2_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(int8_t* base,vuint32m1_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(int8_t* base,vuint32m2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(int8_t* base,vuint32m4_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(int8_t* base,vuint32m8_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(int16_t* base,vuint32mf2_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(int16_t* base,vuint32m1_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(int16_t* base,vuint32m2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(int16_t* base,vuint32m4_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(int16_t* base,vuint32m8_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(int32_t* base,vuint32mf2_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(int32_t* base,vuint32m1_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(int32_t* base,vuint32m2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(int32_t* base,vuint32m4_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(int32_t* base,vuint32m8_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(int64_t* base,vuint32mf2_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(int64_t* base,vuint32m1_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(int64_t* base,vuint32m2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(int64_t* base,vuint32m4_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(uint8_t* base,vuint32mf2_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(uint8_t* base,vuint32m1_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(uint8_t* base,vuint32m2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(uint8_t* base,vuint32m4_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(uint8_t* base,vuint32m8_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(uint16_t* base,vuint32mf2_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(uint16_t* base,vuint32m1_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(uint16_t* base,vuint32m2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(uint16_t* base,vuint32m4_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(uint16_t* base,vuint32m8_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(uint32_t* base,vuint32mf2_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(uint32_t* base,vuint32m1_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(uint32_t* base,vuint32m2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(uint32_t* base,vuint32m4_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(uint32_t* base,vuint32m8_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(uint64_t* base,vuint32mf2_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(uint64_t* base,vuint32m1_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(uint64_t* base,vuint32m2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(uint64_t* base,vuint32m4_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(float* base,vuint32mf2_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(float* base,vuint32m1_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(float* base,vuint32m2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(float* base,vuint32m4_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(float* base,vuint32m8_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(double* base,vuint32mf2_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(double* base,vuint32m1_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(double* base,vuint32m2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(double* base,vuint32m4_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool64_t mask,int8_t* base,vuint32mf2_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool32_t mask,int8_t* base,vuint32m1_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool16_t mask,int8_t* base,vuint32m2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool8_t mask,int8_t* base,vuint32m4_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool4_t mask,int8_t* base,vuint32m8_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool64_t mask,int16_t* base,vuint32mf2_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool32_t mask,int16_t* base,vuint32m1_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool16_t mask,int16_t* base,vuint32m2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool8_t mask,int16_t* base,vuint32m4_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool4_t mask,int16_t* base,vuint32m8_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool64_t mask,int32_t* base,vuint32mf2_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool32_t mask,int32_t* base,vuint32m1_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool16_t mask,int32_t* base,vuint32m2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool8_t mask,int32_t* base,vuint32m4_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool4_t mask,int32_t* base,vuint32m8_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool64_t mask,int64_t* base,vuint32mf2_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool32_t mask,int64_t* base,vuint32m1_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool16_t mask,int64_t* base,vuint32m2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool8_t mask,int64_t* base,vuint32m4_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool64_t mask,uint8_t* base,vuint32mf2_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool32_t mask,uint8_t* base,vuint32m1_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool16_t mask,uint8_t* base,vuint32m2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool8_t mask,uint8_t* base,vuint32m4_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool4_t mask,uint8_t* base,vuint32m8_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool64_t mask,uint16_t* base,vuint32mf2_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool32_t mask,uint16_t* base,vuint32m1_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool16_t mask,uint16_t* base,vuint32m2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool8_t mask,uint16_t* base,vuint32m4_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool4_t mask,uint16_t* base,vuint32m8_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool64_t mask,uint32_t* base,vuint32mf2_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool32_t mask,uint32_t* base,vuint32m1_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool16_t mask,uint32_t* base,vuint32m2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool8_t mask,uint32_t* base,vuint32m4_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool4_t mask,uint32_t* base,vuint32m8_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool64_t mask,uint64_t* base,vuint32mf2_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool32_t mask,uint64_t* base,vuint32m1_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool16_t mask,uint64_t* base,vuint32m2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool8_t mask,uint64_t* base,vuint32m4_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool64_t mask,float* base,vuint32mf2_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool32_t mask,float* base,vuint32m1_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool16_t mask,float* base,vuint32m2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool8_t mask,float* base,vuint32m4_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool4_t mask,float* base,vuint32m8_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool64_t mask,double* base,vuint32mf2_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool32_t mask,double* base,vuint32m1_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool16_t mask,double* base,vuint32m2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32(vbool8_t mask,double* base,vuint32m4_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei32-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei32-3.C
new file mode 100644
index 0000000..0845841
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei32-3.C
@@ -0,0 +1,608 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei32(int8_t* base,vuint32mf2_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(int8_t* base,vuint32m1_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(int8_t* base,vuint32m2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(int8_t* base,vuint32m4_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(int8_t* base,vuint32m8_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(int16_t* base,vuint32mf2_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(int16_t* base,vuint32m1_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(int16_t* base,vuint32m2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(int16_t* base,vuint32m4_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(int16_t* base,vuint32m8_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(int32_t* base,vuint32mf2_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(int32_t* base,vuint32m1_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(int32_t* base,vuint32m2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(int32_t* base,vuint32m4_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(int32_t* base,vuint32m8_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(int64_t* base,vuint32mf2_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(int64_t* base,vuint32m1_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(int64_t* base,vuint32m2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(int64_t* base,vuint32m4_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(uint8_t* base,vuint32mf2_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(uint8_t* base,vuint32m1_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(uint8_t* base,vuint32m2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(uint8_t* base,vuint32m4_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(uint8_t* base,vuint32m8_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(uint16_t* base,vuint32mf2_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(uint16_t* base,vuint32m1_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(uint16_t* base,vuint32m2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(uint16_t* base,vuint32m4_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(uint16_t* base,vuint32m8_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(uint32_t* base,vuint32mf2_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(uint32_t* base,vuint32m1_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(uint32_t* base,vuint32m2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(uint32_t* base,vuint32m4_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(uint32_t* base,vuint32m8_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(uint64_t* base,vuint32mf2_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(uint64_t* base,vuint32m1_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(uint64_t* base,vuint32m2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(uint64_t* base,vuint32m4_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(float* base,vuint32mf2_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(float* base,vuint32m1_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(float* base,vuint32m2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(float* base,vuint32m4_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(float* base,vuint32m8_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(double* base,vuint32mf2_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(double* base,vuint32m1_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(double* base,vuint32m2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(double* base,vuint32m4_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool64_t mask,int8_t* base,vuint32mf2_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool32_t mask,int8_t* base,vuint32m1_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool16_t mask,int8_t* base,vuint32m2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool8_t mask,int8_t* base,vuint32m4_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool4_t mask,int8_t* base,vuint32m8_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool64_t mask,int16_t* base,vuint32mf2_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool32_t mask,int16_t* base,vuint32m1_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool16_t mask,int16_t* base,vuint32m2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool8_t mask,int16_t* base,vuint32m4_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool4_t mask,int16_t* base,vuint32m8_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool64_t mask,int32_t* base,vuint32mf2_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool32_t mask,int32_t* base,vuint32m1_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool16_t mask,int32_t* base,vuint32m2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool8_t mask,int32_t* base,vuint32m4_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool4_t mask,int32_t* base,vuint32m8_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool64_t mask,int64_t* base,vuint32mf2_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool32_t mask,int64_t* base,vuint32m1_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool16_t mask,int64_t* base,vuint32m2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool8_t mask,int64_t* base,vuint32m4_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool64_t mask,uint8_t* base,vuint32mf2_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool32_t mask,uint8_t* base,vuint32m1_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool16_t mask,uint8_t* base,vuint32m2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool8_t mask,uint8_t* base,vuint32m4_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool4_t mask,uint8_t* base,vuint32m8_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool64_t mask,uint16_t* base,vuint32mf2_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool32_t mask,uint16_t* base,vuint32m1_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool16_t mask,uint16_t* base,vuint32m2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool8_t mask,uint16_t* base,vuint32m4_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool4_t mask,uint16_t* base,vuint32m8_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool64_t mask,uint32_t* base,vuint32mf2_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool32_t mask,uint32_t* base,vuint32m1_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool16_t mask,uint32_t* base,vuint32m2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool8_t mask,uint32_t* base,vuint32m4_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool4_t mask,uint32_t* base,vuint32m8_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool64_t mask,uint64_t* base,vuint32mf2_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool32_t mask,uint64_t* base,vuint32m1_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool16_t mask,uint64_t* base,vuint32m2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool8_t mask,uint64_t* base,vuint32m4_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool64_t mask,float* base,vuint32mf2_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool32_t mask,float* base,vuint32m1_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool16_t mask,float* base,vuint32m2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool8_t mask,float* base,vuint32m4_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool4_t mask,float* base,vuint32m8_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool64_t mask,double* base,vuint32mf2_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool32_t mask,double* base,vuint32m1_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool16_t mask,double* base,vuint32m2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32(vbool8_t mask,double* base,vuint32m4_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32(mask,base,bindex,value,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei64-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei64-1.C
new file mode 100644
index 0000000..f8f5938
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei64-1.C
@@ -0,0 +1,518 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei64(int8_t* base,vuint64m1_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(int8_t* base,vuint64m2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(int8_t* base,vuint64m4_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(int8_t* base,vuint64m8_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(int16_t* base,vuint64m1_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(int16_t* base,vuint64m2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(int16_t* base,vuint64m4_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(int16_t* base,vuint64m8_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(int32_t* base,vuint64m1_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(int32_t* base,vuint64m2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(int32_t* base,vuint64m4_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(int32_t* base,vuint64m8_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(int64_t* base,vuint64m1_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(int64_t* base,vuint64m2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(int64_t* base,vuint64m4_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(int64_t* base,vuint64m8_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(uint8_t* base,vuint64m1_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(uint8_t* base,vuint64m2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(uint8_t* base,vuint64m4_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(uint8_t* base,vuint64m8_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(uint16_t* base,vuint64m1_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(uint16_t* base,vuint64m2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(uint16_t* base,vuint64m4_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(uint16_t* base,vuint64m8_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(uint32_t* base,vuint64m1_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(uint32_t* base,vuint64m2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(uint32_t* base,vuint64m4_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(uint32_t* base,vuint64m8_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(uint64_t* base,vuint64m1_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(uint64_t* base,vuint64m2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(uint64_t* base,vuint64m4_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(uint64_t* base,vuint64m8_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(float* base,vuint64m1_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(float* base,vuint64m2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(float* base,vuint64m4_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(float* base,vuint64m8_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(double* base,vuint64m1_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(double* base,vuint64m2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(double* base,vuint64m4_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(double* base,vuint64m8_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool64_t mask,int8_t* base,vuint64m1_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool32_t mask,int8_t* base,vuint64m2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool16_t mask,int8_t* base,vuint64m4_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool8_t mask,int8_t* base,vuint64m8_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool64_t mask,int16_t* base,vuint64m1_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool32_t mask,int16_t* base,vuint64m2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool16_t mask,int16_t* base,vuint64m4_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool8_t mask,int16_t* base,vuint64m8_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool64_t mask,int32_t* base,vuint64m1_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool32_t mask,int32_t* base,vuint64m2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool16_t mask,int32_t* base,vuint64m4_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool8_t mask,int32_t* base,vuint64m8_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool64_t mask,int64_t* base,vuint64m1_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool32_t mask,int64_t* base,vuint64m2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool16_t mask,int64_t* base,vuint64m4_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool8_t mask,int64_t* base,vuint64m8_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool64_t mask,uint8_t* base,vuint64m1_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool32_t mask,uint8_t* base,vuint64m2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool16_t mask,uint8_t* base,vuint64m4_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool8_t mask,uint8_t* base,vuint64m8_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool64_t mask,uint16_t* base,vuint64m1_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool32_t mask,uint16_t* base,vuint64m2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool16_t mask,uint16_t* base,vuint64m4_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool8_t mask,uint16_t* base,vuint64m8_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool64_t mask,uint32_t* base,vuint64m1_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool32_t mask,uint32_t* base,vuint64m2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool16_t mask,uint32_t* base,vuint64m4_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool8_t mask,uint32_t* base,vuint64m8_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool64_t mask,uint64_t* base,vuint64m1_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool32_t mask,uint64_t* base,vuint64m2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool16_t mask,uint64_t* base,vuint64m4_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool8_t mask,uint64_t* base,vuint64m8_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool64_t mask,float* base,vuint64m1_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool32_t mask,float* base,vuint64m2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool16_t mask,float* base,vuint64m4_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool8_t mask,float* base,vuint64m8_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool64_t mask,double* base,vuint64m1_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool32_t mask,double* base,vuint64m2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool16_t mask,double* base,vuint64m4_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64(vbool8_t mask,double* base,vuint64m8_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei64-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei64-2.C
new file mode 100644
index 0000000..0a1c26d
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei64-2.C
@@ -0,0 +1,518 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei64(int8_t* base,vuint64m1_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(int8_t* base,vuint64m2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(int8_t* base,vuint64m4_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(int8_t* base,vuint64m8_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(int16_t* base,vuint64m1_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(int16_t* base,vuint64m2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(int16_t* base,vuint64m4_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(int16_t* base,vuint64m8_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(int32_t* base,vuint64m1_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(int32_t* base,vuint64m2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(int32_t* base,vuint64m4_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(int32_t* base,vuint64m8_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(int64_t* base,vuint64m1_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(int64_t* base,vuint64m2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(int64_t* base,vuint64m4_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(int64_t* base,vuint64m8_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(uint8_t* base,vuint64m1_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(uint8_t* base,vuint64m2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(uint8_t* base,vuint64m4_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(uint8_t* base,vuint64m8_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(uint16_t* base,vuint64m1_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(uint16_t* base,vuint64m2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(uint16_t* base,vuint64m4_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(uint16_t* base,vuint64m8_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(uint32_t* base,vuint64m1_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(uint32_t* base,vuint64m2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(uint32_t* base,vuint64m4_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(uint32_t* base,vuint64m8_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(uint64_t* base,vuint64m1_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(uint64_t* base,vuint64m2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(uint64_t* base,vuint64m4_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(uint64_t* base,vuint64m8_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(float* base,vuint64m1_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(float* base,vuint64m2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(float* base,vuint64m4_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(float* base,vuint64m8_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(double* base,vuint64m1_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(double* base,vuint64m2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(double* base,vuint64m4_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(double* base,vuint64m8_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool64_t mask,int8_t* base,vuint64m1_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool32_t mask,int8_t* base,vuint64m2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool16_t mask,int8_t* base,vuint64m4_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool8_t mask,int8_t* base,vuint64m8_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool64_t mask,int16_t* base,vuint64m1_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool32_t mask,int16_t* base,vuint64m2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool16_t mask,int16_t* base,vuint64m4_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool8_t mask,int16_t* base,vuint64m8_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool64_t mask,int32_t* base,vuint64m1_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool32_t mask,int32_t* base,vuint64m2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool16_t mask,int32_t* base,vuint64m4_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool8_t mask,int32_t* base,vuint64m8_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool64_t mask,int64_t* base,vuint64m1_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool32_t mask,int64_t* base,vuint64m2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool16_t mask,int64_t* base,vuint64m4_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool8_t mask,int64_t* base,vuint64m8_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool64_t mask,uint8_t* base,vuint64m1_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool32_t mask,uint8_t* base,vuint64m2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool16_t mask,uint8_t* base,vuint64m4_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool8_t mask,uint8_t* base,vuint64m8_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool64_t mask,uint16_t* base,vuint64m1_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool32_t mask,uint16_t* base,vuint64m2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool16_t mask,uint16_t* base,vuint64m4_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool8_t mask,uint16_t* base,vuint64m8_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool64_t mask,uint32_t* base,vuint64m1_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool32_t mask,uint32_t* base,vuint64m2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool16_t mask,uint32_t* base,vuint64m4_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool8_t mask,uint32_t* base,vuint64m8_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool64_t mask,uint64_t* base,vuint64m1_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool32_t mask,uint64_t* base,vuint64m2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool16_t mask,uint64_t* base,vuint64m4_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool8_t mask,uint64_t* base,vuint64m8_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool64_t mask,float* base,vuint64m1_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool32_t mask,float* base,vuint64m2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool16_t mask,float* base,vuint64m4_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool8_t mask,float* base,vuint64m8_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool64_t mask,double* base,vuint64m1_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool32_t mask,double* base,vuint64m2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool16_t mask,double* base,vuint64m4_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64(vbool8_t mask,double* base,vuint64m8_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei64-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei64-3.C
new file mode 100644
index 0000000..326c9dc
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei64-3.C
@@ -0,0 +1,518 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei64(int8_t* base,vuint64m1_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(int8_t* base,vuint64m2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(int8_t* base,vuint64m4_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(int8_t* base,vuint64m8_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(int16_t* base,vuint64m1_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(int16_t* base,vuint64m2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(int16_t* base,vuint64m4_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(int16_t* base,vuint64m8_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(int32_t* base,vuint64m1_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(int32_t* base,vuint64m2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(int32_t* base,vuint64m4_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(int32_t* base,vuint64m8_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(int64_t* base,vuint64m1_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(int64_t* base,vuint64m2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(int64_t* base,vuint64m4_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(int64_t* base,vuint64m8_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(uint8_t* base,vuint64m1_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(uint8_t* base,vuint64m2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(uint8_t* base,vuint64m4_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(uint8_t* base,vuint64m8_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(uint16_t* base,vuint64m1_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(uint16_t* base,vuint64m2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(uint16_t* base,vuint64m4_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(uint16_t* base,vuint64m8_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(uint32_t* base,vuint64m1_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(uint32_t* base,vuint64m2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(uint32_t* base,vuint64m4_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(uint32_t* base,vuint64m8_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(uint64_t* base,vuint64m1_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(uint64_t* base,vuint64m2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(uint64_t* base,vuint64m4_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(uint64_t* base,vuint64m8_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(float* base,vuint64m1_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(float* base,vuint64m2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(float* base,vuint64m4_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(float* base,vuint64m8_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(double* base,vuint64m1_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(double* base,vuint64m2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(double* base,vuint64m4_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(double* base,vuint64m8_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool64_t mask,int8_t* base,vuint64m1_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool32_t mask,int8_t* base,vuint64m2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool16_t mask,int8_t* base,vuint64m4_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool8_t mask,int8_t* base,vuint64m8_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool64_t mask,int16_t* base,vuint64m1_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool32_t mask,int16_t* base,vuint64m2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool16_t mask,int16_t* base,vuint64m4_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool8_t mask,int16_t* base,vuint64m8_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool64_t mask,int32_t* base,vuint64m1_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool32_t mask,int32_t* base,vuint64m2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool16_t mask,int32_t* base,vuint64m4_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool8_t mask,int32_t* base,vuint64m8_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool64_t mask,int64_t* base,vuint64m1_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool32_t mask,int64_t* base,vuint64m2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool16_t mask,int64_t* base,vuint64m4_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool8_t mask,int64_t* base,vuint64m8_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool64_t mask,uint8_t* base,vuint64m1_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool32_t mask,uint8_t* base,vuint64m2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool16_t mask,uint8_t* base,vuint64m4_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool8_t mask,uint8_t* base,vuint64m8_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool64_t mask,uint16_t* base,vuint64m1_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool32_t mask,uint16_t* base,vuint64m2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool16_t mask,uint16_t* base,vuint64m4_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool8_t mask,uint16_t* base,vuint64m8_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool64_t mask,uint32_t* base,vuint64m1_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool32_t mask,uint32_t* base,vuint64m2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool16_t mask,uint32_t* base,vuint64m4_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool8_t mask,uint32_t* base,vuint64m8_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool64_t mask,uint64_t* base,vuint64m1_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool32_t mask,uint64_t* base,vuint64m2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool16_t mask,uint64_t* base,vuint64m4_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool8_t mask,uint64_t* base,vuint64m8_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool64_t mask,float* base,vuint64m1_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool32_t mask,float* base,vuint64m2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool16_t mask,float* base,vuint64m4_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool8_t mask,float* base,vuint64m8_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool64_t mask,double* base,vuint64m1_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool32_t mask,double* base,vuint64m2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool16_t mask,double* base,vuint64m4_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64(vbool8_t mask,double* base,vuint64m8_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64(mask,base,bindex,value,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei8-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei8-1.C
new file mode 100644
index 0000000..8abc0ab
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei8-1.C
@@ -0,0 +1,686 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei8(int8_t* base,vuint8mf8_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(int8_t* base,vuint8mf4_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(int8_t* base,vuint8mf2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(int8_t* base,vuint8m1_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(int8_t* base,vuint8m2_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(int8_t* base,vuint8m4_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(int8_t* base,vuint8m8_t bindex,vint8m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(int16_t* base,vuint8mf8_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(int16_t* base,vuint8mf4_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(int16_t* base,vuint8mf2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(int16_t* base,vuint8m1_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(int16_t* base,vuint8m2_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(int16_t* base,vuint8m4_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(int32_t* base,vuint8mf8_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(int32_t* base,vuint8mf4_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(int32_t* base,vuint8mf2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(int32_t* base,vuint8m1_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(int32_t* base,vuint8m2_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(int64_t* base,vuint8mf8_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(int64_t* base,vuint8mf4_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(int64_t* base,vuint8mf2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(int64_t* base,vuint8m1_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(uint8_t* base,vuint8mf8_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(uint8_t* base,vuint8mf4_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(uint8_t* base,vuint8mf2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(uint8_t* base,vuint8m1_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(uint8_t* base,vuint8m2_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(uint8_t* base,vuint8m4_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(uint8_t* base,vuint8m8_t bindex,vuint8m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(uint16_t* base,vuint8mf8_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(uint16_t* base,vuint8mf4_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(uint16_t* base,vuint8mf2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(uint16_t* base,vuint8m1_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(uint16_t* base,vuint8m2_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(uint16_t* base,vuint8m4_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(uint32_t* base,vuint8mf8_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(uint32_t* base,vuint8mf4_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(uint32_t* base,vuint8mf2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(uint32_t* base,vuint8m1_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(uint32_t* base,vuint8m2_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(uint64_t* base,vuint8mf8_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(uint64_t* base,vuint8mf4_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(uint64_t* base,vuint8mf2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(uint64_t* base,vuint8m1_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(float* base,vuint8mf8_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(float* base,vuint8mf4_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(float* base,vuint8mf2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(float* base,vuint8m1_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(float* base,vuint8m2_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(double* base,vuint8mf8_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(double* base,vuint8mf4_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(double* base,vuint8mf2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(double* base,vuint8m1_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool64_t mask,int8_t* base,vuint8mf8_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool32_t mask,int8_t* base,vuint8mf4_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool16_t mask,int8_t* base,vuint8mf2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool8_t mask,int8_t* base,vuint8m1_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool4_t mask,int8_t* base,vuint8m2_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool2_t mask,int8_t* base,vuint8m4_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool1_t mask,int8_t* base,vuint8m8_t bindex,vint8m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool64_t mask,int16_t* base,vuint8mf8_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool32_t mask,int16_t* base,vuint8mf4_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool16_t mask,int16_t* base,vuint8mf2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool8_t mask,int16_t* base,vuint8m1_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool4_t mask,int16_t* base,vuint8m2_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool2_t mask,int16_t* base,vuint8m4_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool64_t mask,int32_t* base,vuint8mf8_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool32_t mask,int32_t* base,vuint8mf4_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool16_t mask,int32_t* base,vuint8mf2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool8_t mask,int32_t* base,vuint8m1_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool4_t mask,int32_t* base,vuint8m2_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool64_t mask,int64_t* base,vuint8mf8_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool32_t mask,int64_t* base,vuint8mf4_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool16_t mask,int64_t* base,vuint8mf2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool8_t mask,int64_t* base,vuint8m1_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool64_t mask,uint8_t* base,vuint8mf8_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool32_t mask,uint8_t* base,vuint8mf4_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool16_t mask,uint8_t* base,vuint8mf2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool8_t mask,uint8_t* base,vuint8m1_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool4_t mask,uint8_t* base,vuint8m2_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool2_t mask,uint8_t* base,vuint8m4_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool1_t mask,uint8_t* base,vuint8m8_t bindex,vuint8m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool64_t mask,uint16_t* base,vuint8mf8_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool32_t mask,uint16_t* base,vuint8mf4_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool16_t mask,uint16_t* base,vuint8mf2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool8_t mask,uint16_t* base,vuint8m1_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool4_t mask,uint16_t* base,vuint8m2_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool2_t mask,uint16_t* base,vuint8m4_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool64_t mask,uint32_t* base,vuint8mf8_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool32_t mask,uint32_t* base,vuint8mf4_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool16_t mask,uint32_t* base,vuint8mf2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool8_t mask,uint32_t* base,vuint8m1_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool4_t mask,uint32_t* base,vuint8m2_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool64_t mask,uint64_t* base,vuint8mf8_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool32_t mask,uint64_t* base,vuint8mf4_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool16_t mask,uint64_t* base,vuint8mf2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool8_t mask,uint64_t* base,vuint8m1_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool64_t mask,float* base,vuint8mf8_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool32_t mask,float* base,vuint8mf4_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool16_t mask,float* base,vuint8mf2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool8_t mask,float* base,vuint8m1_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool4_t mask,float* base,vuint8m2_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool64_t mask,double* base,vuint8mf8_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool32_t mask,double* base,vuint8mf4_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool16_t mask,double* base,vuint8mf2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8(vbool8_t mask,double* base,vuint8m1_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei8-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei8-2.C
new file mode 100644
index 0000000..b876bdf
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei8-2.C
@@ -0,0 +1,686 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei8(int8_t* base,vuint8mf8_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(int8_t* base,vuint8mf4_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(int8_t* base,vuint8mf2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(int8_t* base,vuint8m1_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(int8_t* base,vuint8m2_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(int8_t* base,vuint8m4_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(int8_t* base,vuint8m8_t bindex,vint8m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(int16_t* base,vuint8mf8_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(int16_t* base,vuint8mf4_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(int16_t* base,vuint8mf2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(int16_t* base,vuint8m1_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(int16_t* base,vuint8m2_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(int16_t* base,vuint8m4_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(int32_t* base,vuint8mf8_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(int32_t* base,vuint8mf4_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(int32_t* base,vuint8mf2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(int32_t* base,vuint8m1_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(int32_t* base,vuint8m2_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(int64_t* base,vuint8mf8_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(int64_t* base,vuint8mf4_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(int64_t* base,vuint8mf2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(int64_t* base,vuint8m1_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(uint8_t* base,vuint8mf8_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(uint8_t* base,vuint8mf4_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(uint8_t* base,vuint8mf2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(uint8_t* base,vuint8m1_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(uint8_t* base,vuint8m2_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(uint8_t* base,vuint8m4_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(uint8_t* base,vuint8m8_t bindex,vuint8m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(uint16_t* base,vuint8mf8_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(uint16_t* base,vuint8mf4_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(uint16_t* base,vuint8mf2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(uint16_t* base,vuint8m1_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(uint16_t* base,vuint8m2_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(uint16_t* base,vuint8m4_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(uint32_t* base,vuint8mf8_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(uint32_t* base,vuint8mf4_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(uint32_t* base,vuint8mf2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(uint32_t* base,vuint8m1_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(uint32_t* base,vuint8m2_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(uint64_t* base,vuint8mf8_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(uint64_t* base,vuint8mf4_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(uint64_t* base,vuint8mf2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(uint64_t* base,vuint8m1_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(float* base,vuint8mf8_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(float* base,vuint8mf4_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(float* base,vuint8mf2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(float* base,vuint8m1_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(float* base,vuint8m2_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(double* base,vuint8mf8_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(double* base,vuint8mf4_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(double* base,vuint8mf2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(double* base,vuint8m1_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool64_t mask,int8_t* base,vuint8mf8_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool32_t mask,int8_t* base,vuint8mf4_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool16_t mask,int8_t* base,vuint8mf2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool8_t mask,int8_t* base,vuint8m1_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool4_t mask,int8_t* base,vuint8m2_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool2_t mask,int8_t* base,vuint8m4_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool1_t mask,int8_t* base,vuint8m8_t bindex,vint8m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool64_t mask,int16_t* base,vuint8mf8_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool32_t mask,int16_t* base,vuint8mf4_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool16_t mask,int16_t* base,vuint8mf2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool8_t mask,int16_t* base,vuint8m1_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool4_t mask,int16_t* base,vuint8m2_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool2_t mask,int16_t* base,vuint8m4_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool64_t mask,int32_t* base,vuint8mf8_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool32_t mask,int32_t* base,vuint8mf4_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool16_t mask,int32_t* base,vuint8mf2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool8_t mask,int32_t* base,vuint8m1_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool4_t mask,int32_t* base,vuint8m2_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool64_t mask,int64_t* base,vuint8mf8_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool32_t mask,int64_t* base,vuint8mf4_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool16_t mask,int64_t* base,vuint8mf2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool8_t mask,int64_t* base,vuint8m1_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool64_t mask,uint8_t* base,vuint8mf8_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool32_t mask,uint8_t* base,vuint8mf4_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool16_t mask,uint8_t* base,vuint8mf2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool8_t mask,uint8_t* base,vuint8m1_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool4_t mask,uint8_t* base,vuint8m2_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool2_t mask,uint8_t* base,vuint8m4_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool1_t mask,uint8_t* base,vuint8m8_t bindex,vuint8m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool64_t mask,uint16_t* base,vuint8mf8_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool32_t mask,uint16_t* base,vuint8mf4_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool16_t mask,uint16_t* base,vuint8mf2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool8_t mask,uint16_t* base,vuint8m1_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool4_t mask,uint16_t* base,vuint8m2_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool2_t mask,uint16_t* base,vuint8m4_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool64_t mask,uint32_t* base,vuint8mf8_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool32_t mask,uint32_t* base,vuint8mf4_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool16_t mask,uint32_t* base,vuint8mf2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool8_t mask,uint32_t* base,vuint8m1_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool4_t mask,uint32_t* base,vuint8m2_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool64_t mask,uint64_t* base,vuint8mf8_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool32_t mask,uint64_t* base,vuint8mf4_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool16_t mask,uint64_t* base,vuint8mf2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool8_t mask,uint64_t* base,vuint8m1_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool64_t mask,float* base,vuint8mf8_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool32_t mask,float* base,vuint8mf4_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool16_t mask,float* base,vuint8mf2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool8_t mask,float* base,vuint8m1_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool4_t mask,float* base,vuint8m2_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool64_t mask,double* base,vuint8mf8_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool32_t mask,double* base,vuint8mf4_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool16_t mask,double* base,vuint8mf2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8(vbool8_t mask,double* base,vuint8m1_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei8-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei8-3.C
new file mode 100644
index 0000000..65806e3
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vsoxei8-3.C
@@ -0,0 +1,686 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei8(int8_t* base,vuint8mf8_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(int8_t* base,vuint8mf4_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(int8_t* base,vuint8mf2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(int8_t* base,vuint8m1_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(int8_t* base,vuint8m2_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(int8_t* base,vuint8m4_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(int8_t* base,vuint8m8_t bindex,vint8m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(int16_t* base,vuint8mf8_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(int16_t* base,vuint8mf4_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(int16_t* base,vuint8mf2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(int16_t* base,vuint8m1_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(int16_t* base,vuint8m2_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(int16_t* base,vuint8m4_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(int32_t* base,vuint8mf8_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(int32_t* base,vuint8mf4_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(int32_t* base,vuint8mf2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(int32_t* base,vuint8m1_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(int32_t* base,vuint8m2_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(int64_t* base,vuint8mf8_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(int64_t* base,vuint8mf4_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(int64_t* base,vuint8mf2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(int64_t* base,vuint8m1_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(uint8_t* base,vuint8mf8_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(uint8_t* base,vuint8mf4_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(uint8_t* base,vuint8mf2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(uint8_t* base,vuint8m1_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(uint8_t* base,vuint8m2_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(uint8_t* base,vuint8m4_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(uint8_t* base,vuint8m8_t bindex,vuint8m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(uint16_t* base,vuint8mf8_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(uint16_t* base,vuint8mf4_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(uint16_t* base,vuint8mf2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(uint16_t* base,vuint8m1_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(uint16_t* base,vuint8m2_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(uint16_t* base,vuint8m4_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(uint32_t* base,vuint8mf8_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(uint32_t* base,vuint8mf4_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(uint32_t* base,vuint8mf2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(uint32_t* base,vuint8m1_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(uint32_t* base,vuint8m2_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(uint64_t* base,vuint8mf8_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(uint64_t* base,vuint8mf4_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(uint64_t* base,vuint8mf2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(uint64_t* base,vuint8m1_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(float* base,vuint8mf8_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(float* base,vuint8mf4_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(float* base,vuint8mf2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(float* base,vuint8m1_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(float* base,vuint8m2_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(double* base,vuint8mf8_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(double* base,vuint8mf4_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(double* base,vuint8mf2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(double* base,vuint8m1_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool64_t mask,int8_t* base,vuint8mf8_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool32_t mask,int8_t* base,vuint8mf4_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool16_t mask,int8_t* base,vuint8mf2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool8_t mask,int8_t* base,vuint8m1_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool4_t mask,int8_t* base,vuint8m2_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool2_t mask,int8_t* base,vuint8m4_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool1_t mask,int8_t* base,vuint8m8_t bindex,vint8m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool64_t mask,int16_t* base,vuint8mf8_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool32_t mask,int16_t* base,vuint8mf4_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool16_t mask,int16_t* base,vuint8mf2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool8_t mask,int16_t* base,vuint8m1_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool4_t mask,int16_t* base,vuint8m2_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool2_t mask,int16_t* base,vuint8m4_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool64_t mask,int32_t* base,vuint8mf8_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool32_t mask,int32_t* base,vuint8mf4_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool16_t mask,int32_t* base,vuint8mf2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool8_t mask,int32_t* base,vuint8m1_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool4_t mask,int32_t* base,vuint8m2_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool64_t mask,int64_t* base,vuint8mf8_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool32_t mask,int64_t* base,vuint8mf4_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool16_t mask,int64_t* base,vuint8mf2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool8_t mask,int64_t* base,vuint8m1_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool64_t mask,uint8_t* base,vuint8mf8_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool32_t mask,uint8_t* base,vuint8mf4_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool16_t mask,uint8_t* base,vuint8mf2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool8_t mask,uint8_t* base,vuint8m1_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool4_t mask,uint8_t* base,vuint8m2_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool2_t mask,uint8_t* base,vuint8m4_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool1_t mask,uint8_t* base,vuint8m8_t bindex,vuint8m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool64_t mask,uint16_t* base,vuint8mf8_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool32_t mask,uint16_t* base,vuint8mf4_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool16_t mask,uint16_t* base,vuint8mf2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool8_t mask,uint16_t* base,vuint8m1_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool4_t mask,uint16_t* base,vuint8m2_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool2_t mask,uint16_t* base,vuint8m4_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool64_t mask,uint32_t* base,vuint8mf8_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool32_t mask,uint32_t* base,vuint8mf4_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool16_t mask,uint32_t* base,vuint8mf2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool8_t mask,uint32_t* base,vuint8m1_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool4_t mask,uint32_t* base,vuint8m2_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool64_t mask,uint64_t* base,vuint8mf8_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool32_t mask,uint64_t* base,vuint8mf4_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool16_t mask,uint64_t* base,vuint8mf2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool8_t mask,uint64_t* base,vuint8m1_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool64_t mask,float* base,vuint8mf8_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool32_t mask,float* base,vuint8mf4_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool16_t mask,float* base,vuint8mf2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool8_t mask,float* base,vuint8m1_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool4_t mask,float* base,vuint8m2_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool64_t mask,double* base,vuint8mf8_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool32_t mask,double* base,vuint8mf4_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool16_t mask,double* base,vuint8mf2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8(vbool8_t mask,double* base,vuint8m1_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8(mask,base,bindex,value,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vsse-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vsse-1.C
new file mode 100644
index 0000000..a2d5546
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vsse-1.C
@@ -0,0 +1,685 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void
+test___riscv_vsse8(int8_t* base,ptrdiff_t bstride,vint8mf8_t value,size_t vl)
+{
+  __riscv_vsse8(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8(int8_t* base,ptrdiff_t bstride,vint8mf4_t value,size_t vl)
+{
+  __riscv_vsse8(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8(int8_t* base,ptrdiff_t bstride,vint8mf2_t value,size_t vl)
+{
+  __riscv_vsse8(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8(int8_t* base,ptrdiff_t bstride,vint8m1_t value,size_t vl)
+{
+  __riscv_vsse8(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8(int8_t* base,ptrdiff_t bstride,vint8m2_t value,size_t vl)
+{
+  __riscv_vsse8(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8(int8_t* base,ptrdiff_t bstride,vint8m4_t value,size_t vl)
+{
+  __riscv_vsse8(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8(int8_t* base,ptrdiff_t bstride,vint8m8_t value,size_t vl)
+{
+  __riscv_vsse8(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8(uint8_t* base,ptrdiff_t bstride,vuint8mf8_t value,size_t vl)
+{
+  __riscv_vsse8(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8(uint8_t* base,ptrdiff_t bstride,vuint8mf4_t value,size_t vl)
+{
+  __riscv_vsse8(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8(uint8_t* base,ptrdiff_t bstride,vuint8mf2_t value,size_t vl)
+{
+  __riscv_vsse8(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8(uint8_t* base,ptrdiff_t bstride,vuint8m1_t value,size_t vl)
+{
+  __riscv_vsse8(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8(uint8_t* base,ptrdiff_t bstride,vuint8m2_t value,size_t vl)
+{
+  __riscv_vsse8(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8(uint8_t* base,ptrdiff_t bstride,vuint8m4_t value,size_t vl)
+{
+  __riscv_vsse8(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8(uint8_t* base,ptrdiff_t bstride,vuint8m8_t value,size_t vl)
+{
+  __riscv_vsse8(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8(vbool64_t mask,int8_t* base,ptrdiff_t bstride,vint8mf8_t value,size_t vl)
+{
+  __riscv_vsse8(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8(vbool32_t mask,int8_t* base,ptrdiff_t bstride,vint8mf4_t value,size_t vl)
+{
+  __riscv_vsse8(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8(vbool16_t mask,int8_t* base,ptrdiff_t bstride,vint8mf2_t value,size_t vl)
+{
+  __riscv_vsse8(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8(vbool8_t mask,int8_t* base,ptrdiff_t bstride,vint8m1_t value,size_t vl)
+{
+  __riscv_vsse8(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8(vbool4_t mask,int8_t* base,ptrdiff_t bstride,vint8m2_t value,size_t vl)
+{
+  __riscv_vsse8(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8(vbool2_t mask,int8_t* base,ptrdiff_t bstride,vint8m4_t value,size_t vl)
+{
+  __riscv_vsse8(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8(vbool1_t mask,int8_t* base,ptrdiff_t bstride,vint8m8_t value,size_t vl)
+{
+  __riscv_vsse8(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8(vbool64_t mask,uint8_t* base,ptrdiff_t bstride,vuint8mf8_t value,size_t vl)
+{
+  __riscv_vsse8(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8(vbool32_t mask,uint8_t* base,ptrdiff_t bstride,vuint8mf4_t value,size_t vl)
+{
+  __riscv_vsse8(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8(vbool16_t mask,uint8_t* base,ptrdiff_t bstride,vuint8mf2_t value,size_t vl)
+{
+  __riscv_vsse8(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8(vbool8_t mask,uint8_t* base,ptrdiff_t bstride,vuint8m1_t value,size_t vl)
+{
+  __riscv_vsse8(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8(vbool4_t mask,uint8_t* base,ptrdiff_t bstride,vuint8m2_t value,size_t vl)
+{
+  __riscv_vsse8(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8(vbool2_t mask,uint8_t* base,ptrdiff_t bstride,vuint8m4_t value,size_t vl)
+{
+  __riscv_vsse8(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8(vbool1_t mask,uint8_t* base,ptrdiff_t bstride,vuint8m8_t value,size_t vl)
+{
+  __riscv_vsse8(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16(int16_t* base,ptrdiff_t bstride,vint16mf4_t value,size_t vl)
+{
+  __riscv_vsse16(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16(int16_t* base,ptrdiff_t bstride,vint16mf2_t value,size_t vl)
+{
+  __riscv_vsse16(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16(int16_t* base,ptrdiff_t bstride,vint16m1_t value,size_t vl)
+{
+  __riscv_vsse16(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16(int16_t* base,ptrdiff_t bstride,vint16m2_t value,size_t vl)
+{
+  __riscv_vsse16(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16(int16_t* base,ptrdiff_t bstride,vint16m4_t value,size_t vl)
+{
+  __riscv_vsse16(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16(int16_t* base,ptrdiff_t bstride,vint16m8_t value,size_t vl)
+{
+  __riscv_vsse16(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16(uint16_t* base,ptrdiff_t bstride,vuint16mf4_t value,size_t vl)
+{
+  __riscv_vsse16(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16(uint16_t* base,ptrdiff_t bstride,vuint16mf2_t value,size_t vl)
+{
+  __riscv_vsse16(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16(uint16_t* base,ptrdiff_t bstride,vuint16m1_t value,size_t vl)
+{
+  __riscv_vsse16(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16(uint16_t* base,ptrdiff_t bstride,vuint16m2_t value,size_t vl)
+{
+  __riscv_vsse16(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16(uint16_t* base,ptrdiff_t bstride,vuint16m4_t value,size_t vl)
+{
+  __riscv_vsse16(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16(uint16_t* base,ptrdiff_t bstride,vuint16m8_t value,size_t vl)
+{
+  __riscv_vsse16(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16(vbool64_t mask,int16_t* base,ptrdiff_t bstride,vint16mf4_t value,size_t vl)
+{
+  __riscv_vsse16(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16(vbool32_t mask,int16_t* base,ptrdiff_t bstride,vint16mf2_t value,size_t vl)
+{
+  __riscv_vsse16(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16(vbool16_t mask,int16_t* base,ptrdiff_t bstride,vint16m1_t value,size_t vl)
+{
+  __riscv_vsse16(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16(vbool8_t mask,int16_t* base,ptrdiff_t bstride,vint16m2_t value,size_t vl)
+{
+  __riscv_vsse16(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16(vbool4_t mask,int16_t* base,ptrdiff_t bstride,vint16m4_t value,size_t vl)
+{
+  __riscv_vsse16(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16(vbool2_t mask,int16_t* base,ptrdiff_t bstride,vint16m8_t value,size_t vl)
+{
+  __riscv_vsse16(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16(vbool64_t mask,uint16_t* base,ptrdiff_t bstride,vuint16mf4_t value,size_t vl)
+{
+  __riscv_vsse16(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16(vbool32_t mask,uint16_t* base,ptrdiff_t bstride,vuint16mf2_t value,size_t vl)
+{
+  __riscv_vsse16(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16(vbool16_t mask,uint16_t* base,ptrdiff_t bstride,vuint16m1_t value,size_t vl)
+{
+  __riscv_vsse16(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16(vbool8_t mask,uint16_t* base,ptrdiff_t bstride,vuint16m2_t value,size_t vl)
+{
+  __riscv_vsse16(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16(vbool4_t mask,uint16_t* base,ptrdiff_t bstride,vuint16m4_t value,size_t vl)
+{
+  __riscv_vsse16(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16(vbool2_t mask,uint16_t* base,ptrdiff_t bstride,vuint16m8_t value,size_t vl)
+{
+  __riscv_vsse16(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32(int32_t* base,ptrdiff_t bstride,vint32mf2_t value,size_t vl)
+{
+  __riscv_vsse32(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32(int32_t* base,ptrdiff_t bstride,vint32m1_t value,size_t vl)
+{
+  __riscv_vsse32(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32(int32_t* base,ptrdiff_t bstride,vint32m2_t value,size_t vl)
+{
+  __riscv_vsse32(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32(int32_t* base,ptrdiff_t bstride,vint32m4_t value,size_t vl)
+{
+  __riscv_vsse32(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32(int32_t* base,ptrdiff_t bstride,vint32m8_t value,size_t vl)
+{
+  __riscv_vsse32(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32(uint32_t* base,ptrdiff_t bstride,vuint32mf2_t value,size_t vl)
+{
+  __riscv_vsse32(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32(uint32_t* base,ptrdiff_t bstride,vuint32m1_t value,size_t vl)
+{
+  __riscv_vsse32(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32(uint32_t* base,ptrdiff_t bstride,vuint32m2_t value,size_t vl)
+{
+  __riscv_vsse32(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32(uint32_t* base,ptrdiff_t bstride,vuint32m4_t value,size_t vl)
+{
+  __riscv_vsse32(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32(uint32_t* base,ptrdiff_t bstride,vuint32m8_t value,size_t vl)
+{
+  __riscv_vsse32(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32(float* base,ptrdiff_t bstride,vfloat32mf2_t value,size_t vl)
+{
+  __riscv_vsse32(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32(float* base,ptrdiff_t bstride,vfloat32m1_t value,size_t vl)
+{
+  __riscv_vsse32(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32(float* base,ptrdiff_t bstride,vfloat32m2_t value,size_t vl)
+{
+  __riscv_vsse32(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32(float* base,ptrdiff_t bstride,vfloat32m4_t value,size_t vl)
+{
+  __riscv_vsse32(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32(float* base,ptrdiff_t bstride,vfloat32m8_t value,size_t vl)
+{
+  __riscv_vsse32(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32(vbool64_t mask,int32_t* base,ptrdiff_t bstride,vint32mf2_t value,size_t vl)
+{
+  __riscv_vsse32(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32(vbool32_t mask,int32_t* base,ptrdiff_t bstride,vint32m1_t value,size_t vl)
+{
+  __riscv_vsse32(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32(vbool16_t mask,int32_t* base,ptrdiff_t bstride,vint32m2_t value,size_t vl)
+{
+  __riscv_vsse32(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32(vbool8_t mask,int32_t* base,ptrdiff_t bstride,vint32m4_t value,size_t vl)
+{
+  __riscv_vsse32(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32(vbool4_t mask,int32_t* base,ptrdiff_t bstride,vint32m8_t value,size_t vl)
+{
+  __riscv_vsse32(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32(vbool64_t mask,uint32_t* base,ptrdiff_t bstride,vuint32mf2_t value,size_t vl)
+{
+  __riscv_vsse32(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32(vbool32_t mask,uint32_t* base,ptrdiff_t bstride,vuint32m1_t value,size_t vl)
+{
+  __riscv_vsse32(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32(vbool16_t mask,uint32_t* base,ptrdiff_t bstride,vuint32m2_t value,size_t vl)
+{
+  __riscv_vsse32(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32(vbool8_t mask,uint32_t* base,ptrdiff_t bstride,vuint32m4_t value,size_t vl)
+{
+  __riscv_vsse32(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32(vbool4_t mask,uint32_t* base,ptrdiff_t bstride,vuint32m8_t value,size_t vl)
+{
+  __riscv_vsse32(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32(vbool64_t mask,float* base,ptrdiff_t bstride,vfloat32mf2_t value,size_t vl)
+{
+  __riscv_vsse32(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32(vbool32_t mask,float* base,ptrdiff_t bstride,vfloat32m1_t value,size_t vl)
+{
+  __riscv_vsse32(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32(vbool16_t mask,float* base,ptrdiff_t bstride,vfloat32m2_t value,size_t vl)
+{
+  __riscv_vsse32(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32(vbool8_t mask,float* base,ptrdiff_t bstride,vfloat32m4_t value,size_t vl)
+{
+  __riscv_vsse32(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32(vbool4_t mask,float* base,ptrdiff_t bstride,vfloat32m8_t value,size_t vl)
+{
+  __riscv_vsse32(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64(int64_t* base,ptrdiff_t bstride,vint64m1_t value,size_t vl)
+{
+  __riscv_vsse64(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64(int64_t* base,ptrdiff_t bstride,vint64m2_t value,size_t vl)
+{
+  __riscv_vsse64(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64(int64_t* base,ptrdiff_t bstride,vint64m4_t value,size_t vl)
+{
+  __riscv_vsse64(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64(int64_t* base,ptrdiff_t bstride,vint64m8_t value,size_t vl)
+{
+  __riscv_vsse64(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64(uint64_t* base,ptrdiff_t bstride,vuint64m1_t value,size_t vl)
+{
+  __riscv_vsse64(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64(uint64_t* base,ptrdiff_t bstride,vuint64m2_t value,size_t vl)
+{
+  __riscv_vsse64(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64(uint64_t* base,ptrdiff_t bstride,vuint64m4_t value,size_t vl)
+{
+  __riscv_vsse64(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64(uint64_t* base,ptrdiff_t bstride,vuint64m8_t value,size_t vl)
+{
+  __riscv_vsse64(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64(double* base,ptrdiff_t bstride,vfloat64m1_t value,size_t vl)
+{
+  __riscv_vsse64(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64(double* base,ptrdiff_t bstride,vfloat64m2_t value,size_t vl)
+{
+  __riscv_vsse64(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64(double* base,ptrdiff_t bstride,vfloat64m4_t value,size_t vl)
+{
+  __riscv_vsse64(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64(double* base,ptrdiff_t bstride,vfloat64m8_t value,size_t vl)
+{
+  __riscv_vsse64(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64(vbool64_t mask,int64_t* base,ptrdiff_t bstride,vint64m1_t value,size_t vl)
+{
+  __riscv_vsse64(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64(vbool32_t mask,int64_t* base,ptrdiff_t bstride,vint64m2_t value,size_t vl)
+{
+  __riscv_vsse64(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64(vbool16_t mask,int64_t* base,ptrdiff_t bstride,vint64m4_t value,size_t vl)
+{
+  __riscv_vsse64(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64(vbool8_t mask,int64_t* base,ptrdiff_t bstride,vint64m8_t value,size_t vl)
+{
+  __riscv_vsse64(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64(vbool64_t mask,uint64_t* base,ptrdiff_t bstride,vuint64m1_t value,size_t vl)
+{
+  __riscv_vsse64(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64(vbool32_t mask,uint64_t* base,ptrdiff_t bstride,vuint64m2_t value,size_t vl)
+{
+  __riscv_vsse64(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64(vbool16_t mask,uint64_t* base,ptrdiff_t bstride,vuint64m4_t value,size_t vl)
+{
+  __riscv_vsse64(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64(vbool8_t mask,uint64_t* base,ptrdiff_t bstride,vuint64m8_t value,size_t vl)
+{
+  __riscv_vsse64(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64(vbool64_t mask,double* base,ptrdiff_t bstride,vfloat64m1_t value,size_t vl)
+{
+  __riscv_vsse64(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64(vbool32_t mask,double* base,ptrdiff_t bstride,vfloat64m2_t value,size_t vl)
+{
+  __riscv_vsse64(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64(vbool16_t mask,double* base,ptrdiff_t bstride,vfloat64m4_t value,size_t vl)
+{
+  __riscv_vsse64(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64(vbool8_t mask,double* base,ptrdiff_t bstride,vfloat64m8_t value,size_t vl)
+{
+  __riscv_vsse64(mask,base,bstride,value,vl);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei16-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei16-1.C
new file mode 100644
index 0000000..85d4dbe
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei16-1.C
@@ -0,0 +1,660 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei16(int8_t* base,vuint16mf4_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(int8_t* base,vuint16mf2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(int8_t* base,vuint16m1_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(int8_t* base,vuint16m2_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(int8_t* base,vuint16m4_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(int8_t* base,vuint16m8_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(int16_t* base,vuint16mf4_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(int16_t* base,vuint16mf2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(int16_t* base,vuint16m1_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(int16_t* base,vuint16m2_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(int16_t* base,vuint16m4_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(int16_t* base,vuint16m8_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(int32_t* base,vuint16mf4_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(int32_t* base,vuint16mf2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(int32_t* base,vuint16m1_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(int32_t* base,vuint16m2_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(int32_t* base,vuint16m4_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(int64_t* base,vuint16mf4_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(int64_t* base,vuint16mf2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(int64_t* base,vuint16m1_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(int64_t* base,vuint16m2_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(uint8_t* base,vuint16mf4_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(uint8_t* base,vuint16mf2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(uint8_t* base,vuint16m1_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(uint8_t* base,vuint16m2_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(uint8_t* base,vuint16m4_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(uint8_t* base,vuint16m8_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(uint16_t* base,vuint16mf4_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(uint16_t* base,vuint16mf2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(uint16_t* base,vuint16m1_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(uint16_t* base,vuint16m2_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(uint16_t* base,vuint16m4_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(uint16_t* base,vuint16m8_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(uint32_t* base,vuint16mf4_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(uint32_t* base,vuint16mf2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(uint32_t* base,vuint16m1_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(uint32_t* base,vuint16m2_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(uint32_t* base,vuint16m4_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(uint64_t* base,vuint16mf4_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(uint64_t* base,vuint16mf2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(uint64_t* base,vuint16m1_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(uint64_t* base,vuint16m2_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(float* base,vuint16mf4_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(float* base,vuint16mf2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(float* base,vuint16m1_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(float* base,vuint16m2_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(float* base,vuint16m4_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(double* base,vuint16mf4_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(double* base,vuint16mf2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(double* base,vuint16m1_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(double* base,vuint16m2_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool64_t mask,int8_t* base,vuint16mf4_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool32_t mask,int8_t* base,vuint16mf2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool16_t mask,int8_t* base,vuint16m1_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool8_t mask,int8_t* base,vuint16m2_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool4_t mask,int8_t* base,vuint16m4_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool2_t mask,int8_t* base,vuint16m8_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool64_t mask,int16_t* base,vuint16mf4_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool32_t mask,int16_t* base,vuint16mf2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool16_t mask,int16_t* base,vuint16m1_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool8_t mask,int16_t* base,vuint16m2_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool4_t mask,int16_t* base,vuint16m4_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool2_t mask,int16_t* base,vuint16m8_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool64_t mask,int32_t* base,vuint16mf4_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool32_t mask,int32_t* base,vuint16mf2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool16_t mask,int32_t* base,vuint16m1_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool8_t mask,int32_t* base,vuint16m2_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool4_t mask,int32_t* base,vuint16m4_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool64_t mask,int64_t* base,vuint16mf4_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool32_t mask,int64_t* base,vuint16mf2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool16_t mask,int64_t* base,vuint16m1_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool8_t mask,int64_t* base,vuint16m2_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool64_t mask,uint8_t* base,vuint16mf4_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool32_t mask,uint8_t* base,vuint16mf2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool16_t mask,uint8_t* base,vuint16m1_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool8_t mask,uint8_t* base,vuint16m2_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool4_t mask,uint8_t* base,vuint16m4_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool2_t mask,uint8_t* base,vuint16m8_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool64_t mask,uint16_t* base,vuint16mf4_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool32_t mask,uint16_t* base,vuint16mf2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool16_t mask,uint16_t* base,vuint16m1_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool8_t mask,uint16_t* base,vuint16m2_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool4_t mask,uint16_t* base,vuint16m4_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool2_t mask,uint16_t* base,vuint16m8_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool64_t mask,uint32_t* base,vuint16mf4_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool32_t mask,uint32_t* base,vuint16mf2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool16_t mask,uint32_t* base,vuint16m1_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool8_t mask,uint32_t* base,vuint16m2_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool4_t mask,uint32_t* base,vuint16m4_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool64_t mask,uint64_t* base,vuint16mf4_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool32_t mask,uint64_t* base,vuint16mf2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool16_t mask,uint64_t* base,vuint16m1_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool8_t mask,uint64_t* base,vuint16m2_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool64_t mask,float* base,vuint16mf4_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool32_t mask,float* base,vuint16mf2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool16_t mask,float* base,vuint16m1_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool8_t mask,float* base,vuint16m2_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool4_t mask,float* base,vuint16m4_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool64_t mask,double* base,vuint16mf4_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool32_t mask,double* base,vuint16mf2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool16_t mask,double* base,vuint16m1_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16(vbool8_t mask,double* base,vuint16m2_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei16-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei16-2.C
new file mode 100644
index 0000000..8131d2c
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei16-2.C
@@ -0,0 +1,660 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei16(int8_t* base,vuint16mf4_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(int8_t* base,vuint16mf2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(int8_t* base,vuint16m1_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(int8_t* base,vuint16m2_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(int8_t* base,vuint16m4_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(int8_t* base,vuint16m8_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(int16_t* base,vuint16mf4_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(int16_t* base,vuint16mf2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(int16_t* base,vuint16m1_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(int16_t* base,vuint16m2_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(int16_t* base,vuint16m4_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(int16_t* base,vuint16m8_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(int32_t* base,vuint16mf4_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(int32_t* base,vuint16mf2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(int32_t* base,vuint16m1_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(int32_t* base,vuint16m2_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(int32_t* base,vuint16m4_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(int64_t* base,vuint16mf4_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(int64_t* base,vuint16mf2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(int64_t* base,vuint16m1_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(int64_t* base,vuint16m2_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(uint8_t* base,vuint16mf4_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(uint8_t* base,vuint16mf2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(uint8_t* base,vuint16m1_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(uint8_t* base,vuint16m2_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(uint8_t* base,vuint16m4_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(uint8_t* base,vuint16m8_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(uint16_t* base,vuint16mf4_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(uint16_t* base,vuint16mf2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(uint16_t* base,vuint16m1_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(uint16_t* base,vuint16m2_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(uint16_t* base,vuint16m4_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(uint16_t* base,vuint16m8_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(uint32_t* base,vuint16mf4_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(uint32_t* base,vuint16mf2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(uint32_t* base,vuint16m1_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(uint32_t* base,vuint16m2_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(uint32_t* base,vuint16m4_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(uint64_t* base,vuint16mf4_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(uint64_t* base,vuint16mf2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(uint64_t* base,vuint16m1_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(uint64_t* base,vuint16m2_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(float* base,vuint16mf4_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(float* base,vuint16mf2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(float* base,vuint16m1_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(float* base,vuint16m2_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(float* base,vuint16m4_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(double* base,vuint16mf4_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(double* base,vuint16mf2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(double* base,vuint16m1_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(double* base,vuint16m2_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool64_t mask,int8_t* base,vuint16mf4_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool32_t mask,int8_t* base,vuint16mf2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool16_t mask,int8_t* base,vuint16m1_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool8_t mask,int8_t* base,vuint16m2_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool4_t mask,int8_t* base,vuint16m4_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool2_t mask,int8_t* base,vuint16m8_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool64_t mask,int16_t* base,vuint16mf4_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool32_t mask,int16_t* base,vuint16mf2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool16_t mask,int16_t* base,vuint16m1_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool8_t mask,int16_t* base,vuint16m2_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool4_t mask,int16_t* base,vuint16m4_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool2_t mask,int16_t* base,vuint16m8_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool64_t mask,int32_t* base,vuint16mf4_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool32_t mask,int32_t* base,vuint16mf2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool16_t mask,int32_t* base,vuint16m1_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool8_t mask,int32_t* base,vuint16m2_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool4_t mask,int32_t* base,vuint16m4_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool64_t mask,int64_t* base,vuint16mf4_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool32_t mask,int64_t* base,vuint16mf2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool16_t mask,int64_t* base,vuint16m1_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool8_t mask,int64_t* base,vuint16m2_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool64_t mask,uint8_t* base,vuint16mf4_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool32_t mask,uint8_t* base,vuint16mf2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool16_t mask,uint8_t* base,vuint16m1_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool8_t mask,uint8_t* base,vuint16m2_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool4_t mask,uint8_t* base,vuint16m4_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool2_t mask,uint8_t* base,vuint16m8_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool64_t mask,uint16_t* base,vuint16mf4_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool32_t mask,uint16_t* base,vuint16mf2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool16_t mask,uint16_t* base,vuint16m1_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool8_t mask,uint16_t* base,vuint16m2_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool4_t mask,uint16_t* base,vuint16m4_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool2_t mask,uint16_t* base,vuint16m8_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool64_t mask,uint32_t* base,vuint16mf4_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool32_t mask,uint32_t* base,vuint16mf2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool16_t mask,uint32_t* base,vuint16m1_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool8_t mask,uint32_t* base,vuint16m2_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool4_t mask,uint32_t* base,vuint16m4_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool64_t mask,uint64_t* base,vuint16mf4_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool32_t mask,uint64_t* base,vuint16mf2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool16_t mask,uint64_t* base,vuint16m1_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool8_t mask,uint64_t* base,vuint16m2_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool64_t mask,float* base,vuint16mf4_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool32_t mask,float* base,vuint16mf2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool16_t mask,float* base,vuint16m1_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool8_t mask,float* base,vuint16m2_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool4_t mask,float* base,vuint16m4_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool64_t mask,double* base,vuint16mf4_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool32_t mask,double* base,vuint16mf2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool16_t mask,double* base,vuint16m1_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16(vbool8_t mask,double* base,vuint16m2_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei16-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei16-3.C
new file mode 100644
index 0000000..01fc4f6
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei16-3.C
@@ -0,0 +1,660 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei16(int8_t* base,vuint16mf4_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(int8_t* base,vuint16mf2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(int8_t* base,vuint16m1_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(int8_t* base,vuint16m2_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(int8_t* base,vuint16m4_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(int8_t* base,vuint16m8_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(int16_t* base,vuint16mf4_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(int16_t* base,vuint16mf2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(int16_t* base,vuint16m1_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(int16_t* base,vuint16m2_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(int16_t* base,vuint16m4_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(int16_t* base,vuint16m8_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(int32_t* base,vuint16mf4_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(int32_t* base,vuint16mf2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(int32_t* base,vuint16m1_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(int32_t* base,vuint16m2_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(int32_t* base,vuint16m4_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(int64_t* base,vuint16mf4_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(int64_t* base,vuint16mf2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(int64_t* base,vuint16m1_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(int64_t* base,vuint16m2_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(uint8_t* base,vuint16mf4_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(uint8_t* base,vuint16mf2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(uint8_t* base,vuint16m1_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(uint8_t* base,vuint16m2_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(uint8_t* base,vuint16m4_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(uint8_t* base,vuint16m8_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(uint16_t* base,vuint16mf4_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(uint16_t* base,vuint16mf2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(uint16_t* base,vuint16m1_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(uint16_t* base,vuint16m2_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(uint16_t* base,vuint16m4_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(uint16_t* base,vuint16m8_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(uint32_t* base,vuint16mf4_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(uint32_t* base,vuint16mf2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(uint32_t* base,vuint16m1_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(uint32_t* base,vuint16m2_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(uint32_t* base,vuint16m4_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(uint64_t* base,vuint16mf4_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(uint64_t* base,vuint16mf2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(uint64_t* base,vuint16m1_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(uint64_t* base,vuint16m2_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(float* base,vuint16mf4_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(float* base,vuint16mf2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(float* base,vuint16m1_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(float* base,vuint16m2_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(float* base,vuint16m4_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(double* base,vuint16mf4_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(double* base,vuint16mf2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(double* base,vuint16m1_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(double* base,vuint16m2_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool64_t mask,int8_t* base,vuint16mf4_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool32_t mask,int8_t* base,vuint16mf2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool16_t mask,int8_t* base,vuint16m1_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool8_t mask,int8_t* base,vuint16m2_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool4_t mask,int8_t* base,vuint16m4_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool2_t mask,int8_t* base,vuint16m8_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool64_t mask,int16_t* base,vuint16mf4_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool32_t mask,int16_t* base,vuint16mf2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool16_t mask,int16_t* base,vuint16m1_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool8_t mask,int16_t* base,vuint16m2_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool4_t mask,int16_t* base,vuint16m4_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool2_t mask,int16_t* base,vuint16m8_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool64_t mask,int32_t* base,vuint16mf4_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool32_t mask,int32_t* base,vuint16mf2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool16_t mask,int32_t* base,vuint16m1_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool8_t mask,int32_t* base,vuint16m2_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool4_t mask,int32_t* base,vuint16m4_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool64_t mask,int64_t* base,vuint16mf4_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool32_t mask,int64_t* base,vuint16mf2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool16_t mask,int64_t* base,vuint16m1_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool8_t mask,int64_t* base,vuint16m2_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool64_t mask,uint8_t* base,vuint16mf4_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool32_t mask,uint8_t* base,vuint16mf2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool16_t mask,uint8_t* base,vuint16m1_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool8_t mask,uint8_t* base,vuint16m2_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool4_t mask,uint8_t* base,vuint16m4_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool2_t mask,uint8_t* base,vuint16m8_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool64_t mask,uint16_t* base,vuint16mf4_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool32_t mask,uint16_t* base,vuint16mf2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool16_t mask,uint16_t* base,vuint16m1_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool8_t mask,uint16_t* base,vuint16m2_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool4_t mask,uint16_t* base,vuint16m4_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool2_t mask,uint16_t* base,vuint16m8_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool64_t mask,uint32_t* base,vuint16mf4_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool32_t mask,uint32_t* base,vuint16mf2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool16_t mask,uint32_t* base,vuint16m1_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool8_t mask,uint32_t* base,vuint16m2_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool4_t mask,uint32_t* base,vuint16m4_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool64_t mask,uint64_t* base,vuint16mf4_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool32_t mask,uint64_t* base,vuint16mf2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool16_t mask,uint64_t* base,vuint16m1_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool8_t mask,uint64_t* base,vuint16m2_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool64_t mask,float* base,vuint16mf4_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool32_t mask,float* base,vuint16mf2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool16_t mask,float* base,vuint16m1_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool8_t mask,float* base,vuint16m2_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool4_t mask,float* base,vuint16m4_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool64_t mask,double* base,vuint16mf4_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool32_t mask,double* base,vuint16mf2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool16_t mask,double* base,vuint16m1_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16(vbool8_t mask,double* base,vuint16m2_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16(mask,base,bindex,value,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei32-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei32-1.C
new file mode 100644
index 0000000..8a00db8
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei32-1.C
@@ -0,0 +1,608 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei32(int8_t* base,vuint32mf2_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(int8_t* base,vuint32m1_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(int8_t* base,vuint32m2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(int8_t* base,vuint32m4_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(int8_t* base,vuint32m8_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(int16_t* base,vuint32mf2_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(int16_t* base,vuint32m1_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(int16_t* base,vuint32m2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(int16_t* base,vuint32m4_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(int16_t* base,vuint32m8_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(int32_t* base,vuint32mf2_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(int32_t* base,vuint32m1_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(int32_t* base,vuint32m2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(int32_t* base,vuint32m4_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(int32_t* base,vuint32m8_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(int64_t* base,vuint32mf2_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(int64_t* base,vuint32m1_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(int64_t* base,vuint32m2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(int64_t* base,vuint32m4_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(uint8_t* base,vuint32mf2_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(uint8_t* base,vuint32m1_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(uint8_t* base,vuint32m2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(uint8_t* base,vuint32m4_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(uint8_t* base,vuint32m8_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(uint16_t* base,vuint32mf2_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(uint16_t* base,vuint32m1_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(uint16_t* base,vuint32m2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(uint16_t* base,vuint32m4_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(uint16_t* base,vuint32m8_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(uint32_t* base,vuint32mf2_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(uint32_t* base,vuint32m1_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(uint32_t* base,vuint32m2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(uint32_t* base,vuint32m4_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(uint32_t* base,vuint32m8_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(uint64_t* base,vuint32mf2_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(uint64_t* base,vuint32m1_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(uint64_t* base,vuint32m2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(uint64_t* base,vuint32m4_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(float* base,vuint32mf2_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(float* base,vuint32m1_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(float* base,vuint32m2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(float* base,vuint32m4_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(float* base,vuint32m8_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(double* base,vuint32mf2_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(double* base,vuint32m1_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(double* base,vuint32m2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(double* base,vuint32m4_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool64_t mask,int8_t* base,vuint32mf2_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool32_t mask,int8_t* base,vuint32m1_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool16_t mask,int8_t* base,vuint32m2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool8_t mask,int8_t* base,vuint32m4_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool4_t mask,int8_t* base,vuint32m8_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool64_t mask,int16_t* base,vuint32mf2_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool32_t mask,int16_t* base,vuint32m1_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool16_t mask,int16_t* base,vuint32m2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool8_t mask,int16_t* base,vuint32m4_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool4_t mask,int16_t* base,vuint32m8_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool64_t mask,int32_t* base,vuint32mf2_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool32_t mask,int32_t* base,vuint32m1_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool16_t mask,int32_t* base,vuint32m2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool8_t mask,int32_t* base,vuint32m4_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool4_t mask,int32_t* base,vuint32m8_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool64_t mask,int64_t* base,vuint32mf2_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool32_t mask,int64_t* base,vuint32m1_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool16_t mask,int64_t* base,vuint32m2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool8_t mask,int64_t* base,vuint32m4_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool64_t mask,uint8_t* base,vuint32mf2_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool32_t mask,uint8_t* base,vuint32m1_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool16_t mask,uint8_t* base,vuint32m2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool8_t mask,uint8_t* base,vuint32m4_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool4_t mask,uint8_t* base,vuint32m8_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool64_t mask,uint16_t* base,vuint32mf2_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool32_t mask,uint16_t* base,vuint32m1_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool16_t mask,uint16_t* base,vuint32m2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool8_t mask,uint16_t* base,vuint32m4_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool4_t mask,uint16_t* base,vuint32m8_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool64_t mask,uint32_t* base,vuint32mf2_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool32_t mask,uint32_t* base,vuint32m1_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool16_t mask,uint32_t* base,vuint32m2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool8_t mask,uint32_t* base,vuint32m4_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool4_t mask,uint32_t* base,vuint32m8_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool64_t mask,uint64_t* base,vuint32mf2_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool32_t mask,uint64_t* base,vuint32m1_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool16_t mask,uint64_t* base,vuint32m2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool8_t mask,uint64_t* base,vuint32m4_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool64_t mask,float* base,vuint32mf2_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool32_t mask,float* base,vuint32m1_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool16_t mask,float* base,vuint32m2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool8_t mask,float* base,vuint32m4_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool4_t mask,float* base,vuint32m8_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool64_t mask,double* base,vuint32mf2_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool32_t mask,double* base,vuint32m1_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool16_t mask,double* base,vuint32m2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32(vbool8_t mask,double* base,vuint32m4_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei32-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei32-2.C
new file mode 100644
index 0000000..b7bfa42
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei32-2.C
@@ -0,0 +1,608 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei32(int8_t* base,vuint32mf2_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(int8_t* base,vuint32m1_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(int8_t* base,vuint32m2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(int8_t* base,vuint32m4_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(int8_t* base,vuint32m8_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(int16_t* base,vuint32mf2_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(int16_t* base,vuint32m1_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(int16_t* base,vuint32m2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(int16_t* base,vuint32m4_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(int16_t* base,vuint32m8_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(int32_t* base,vuint32mf2_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(int32_t* base,vuint32m1_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(int32_t* base,vuint32m2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(int32_t* base,vuint32m4_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(int32_t* base,vuint32m8_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(int64_t* base,vuint32mf2_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(int64_t* base,vuint32m1_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(int64_t* base,vuint32m2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(int64_t* base,vuint32m4_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(uint8_t* base,vuint32mf2_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(uint8_t* base,vuint32m1_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(uint8_t* base,vuint32m2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(uint8_t* base,vuint32m4_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(uint8_t* base,vuint32m8_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(uint16_t* base,vuint32mf2_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(uint16_t* base,vuint32m1_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(uint16_t* base,vuint32m2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(uint16_t* base,vuint32m4_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(uint16_t* base,vuint32m8_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(uint32_t* base,vuint32mf2_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(uint32_t* base,vuint32m1_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(uint32_t* base,vuint32m2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(uint32_t* base,vuint32m4_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(uint32_t* base,vuint32m8_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(uint64_t* base,vuint32mf2_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(uint64_t* base,vuint32m1_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(uint64_t* base,vuint32m2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(uint64_t* base,vuint32m4_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(float* base,vuint32mf2_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(float* base,vuint32m1_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(float* base,vuint32m2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(float* base,vuint32m4_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(float* base,vuint32m8_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(double* base,vuint32mf2_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(double* base,vuint32m1_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(double* base,vuint32m2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(double* base,vuint32m4_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool64_t mask,int8_t* base,vuint32mf2_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool32_t mask,int8_t* base,vuint32m1_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool16_t mask,int8_t* base,vuint32m2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool8_t mask,int8_t* base,vuint32m4_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool4_t mask,int8_t* base,vuint32m8_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool64_t mask,int16_t* base,vuint32mf2_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool32_t mask,int16_t* base,vuint32m1_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool16_t mask,int16_t* base,vuint32m2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool8_t mask,int16_t* base,vuint32m4_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool4_t mask,int16_t* base,vuint32m8_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool64_t mask,int32_t* base,vuint32mf2_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool32_t mask,int32_t* base,vuint32m1_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool16_t mask,int32_t* base,vuint32m2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool8_t mask,int32_t* base,vuint32m4_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool4_t mask,int32_t* base,vuint32m8_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool64_t mask,int64_t* base,vuint32mf2_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool32_t mask,int64_t* base,vuint32m1_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool16_t mask,int64_t* base,vuint32m2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool8_t mask,int64_t* base,vuint32m4_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool64_t mask,uint8_t* base,vuint32mf2_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool32_t mask,uint8_t* base,vuint32m1_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool16_t mask,uint8_t* base,vuint32m2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool8_t mask,uint8_t* base,vuint32m4_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool4_t mask,uint8_t* base,vuint32m8_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool64_t mask,uint16_t* base,vuint32mf2_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool32_t mask,uint16_t* base,vuint32m1_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool16_t mask,uint16_t* base,vuint32m2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool8_t mask,uint16_t* base,vuint32m4_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool4_t mask,uint16_t* base,vuint32m8_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool64_t mask,uint32_t* base,vuint32mf2_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool32_t mask,uint32_t* base,vuint32m1_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool16_t mask,uint32_t* base,vuint32m2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool8_t mask,uint32_t* base,vuint32m4_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool4_t mask,uint32_t* base,vuint32m8_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool64_t mask,uint64_t* base,vuint32mf2_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool32_t mask,uint64_t* base,vuint32m1_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool16_t mask,uint64_t* base,vuint32m2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool8_t mask,uint64_t* base,vuint32m4_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool64_t mask,float* base,vuint32mf2_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool32_t mask,float* base,vuint32m1_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool16_t mask,float* base,vuint32m2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool8_t mask,float* base,vuint32m4_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool4_t mask,float* base,vuint32m8_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool64_t mask,double* base,vuint32mf2_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool32_t mask,double* base,vuint32m1_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool16_t mask,double* base,vuint32m2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32(vbool8_t mask,double* base,vuint32m4_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei32-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei32-3.C
new file mode 100644
index 0000000..381fbe4
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei32-3.C
@@ -0,0 +1,608 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei32(int8_t* base,vuint32mf2_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(int8_t* base,vuint32m1_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(int8_t* base,vuint32m2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(int8_t* base,vuint32m4_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(int8_t* base,vuint32m8_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(int16_t* base,vuint32mf2_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(int16_t* base,vuint32m1_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(int16_t* base,vuint32m2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(int16_t* base,vuint32m4_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(int16_t* base,vuint32m8_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(int32_t* base,vuint32mf2_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(int32_t* base,vuint32m1_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(int32_t* base,vuint32m2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(int32_t* base,vuint32m4_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(int32_t* base,vuint32m8_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(int64_t* base,vuint32mf2_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(int64_t* base,vuint32m1_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(int64_t* base,vuint32m2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(int64_t* base,vuint32m4_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(uint8_t* base,vuint32mf2_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(uint8_t* base,vuint32m1_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(uint8_t* base,vuint32m2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(uint8_t* base,vuint32m4_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(uint8_t* base,vuint32m8_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(uint16_t* base,vuint32mf2_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(uint16_t* base,vuint32m1_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(uint16_t* base,vuint32m2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(uint16_t* base,vuint32m4_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(uint16_t* base,vuint32m8_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(uint32_t* base,vuint32mf2_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(uint32_t* base,vuint32m1_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(uint32_t* base,vuint32m2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(uint32_t* base,vuint32m4_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(uint32_t* base,vuint32m8_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(uint64_t* base,vuint32mf2_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(uint64_t* base,vuint32m1_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(uint64_t* base,vuint32m2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(uint64_t* base,vuint32m4_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(float* base,vuint32mf2_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(float* base,vuint32m1_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(float* base,vuint32m2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(float* base,vuint32m4_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(float* base,vuint32m8_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(double* base,vuint32mf2_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(double* base,vuint32m1_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(double* base,vuint32m2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(double* base,vuint32m4_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool64_t mask,int8_t* base,vuint32mf2_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool32_t mask,int8_t* base,vuint32m1_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool16_t mask,int8_t* base,vuint32m2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool8_t mask,int8_t* base,vuint32m4_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool4_t mask,int8_t* base,vuint32m8_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool64_t mask,int16_t* base,vuint32mf2_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool32_t mask,int16_t* base,vuint32m1_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool16_t mask,int16_t* base,vuint32m2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool8_t mask,int16_t* base,vuint32m4_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool4_t mask,int16_t* base,vuint32m8_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool64_t mask,int32_t* base,vuint32mf2_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool32_t mask,int32_t* base,vuint32m1_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool16_t mask,int32_t* base,vuint32m2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool8_t mask,int32_t* base,vuint32m4_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool4_t mask,int32_t* base,vuint32m8_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool64_t mask,int64_t* base,vuint32mf2_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool32_t mask,int64_t* base,vuint32m1_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool16_t mask,int64_t* base,vuint32m2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool8_t mask,int64_t* base,vuint32m4_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool64_t mask,uint8_t* base,vuint32mf2_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool32_t mask,uint8_t* base,vuint32m1_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool16_t mask,uint8_t* base,vuint32m2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool8_t mask,uint8_t* base,vuint32m4_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool4_t mask,uint8_t* base,vuint32m8_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool64_t mask,uint16_t* base,vuint32mf2_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool32_t mask,uint16_t* base,vuint32m1_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool16_t mask,uint16_t* base,vuint32m2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool8_t mask,uint16_t* base,vuint32m4_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool4_t mask,uint16_t* base,vuint32m8_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool64_t mask,uint32_t* base,vuint32mf2_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool32_t mask,uint32_t* base,vuint32m1_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool16_t mask,uint32_t* base,vuint32m2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool8_t mask,uint32_t* base,vuint32m4_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool4_t mask,uint32_t* base,vuint32m8_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool64_t mask,uint64_t* base,vuint32mf2_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool32_t mask,uint64_t* base,vuint32m1_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool16_t mask,uint64_t* base,vuint32m2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool8_t mask,uint64_t* base,vuint32m4_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool64_t mask,float* base,vuint32mf2_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool32_t mask,float* base,vuint32m1_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool16_t mask,float* base,vuint32m2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool8_t mask,float* base,vuint32m4_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool4_t mask,float* base,vuint32m8_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool64_t mask,double* base,vuint32mf2_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool32_t mask,double* base,vuint32m1_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool16_t mask,double* base,vuint32m2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32(vbool8_t mask,double* base,vuint32m4_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32(mask,base,bindex,value,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei64-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei64-1.C
new file mode 100644
index 0000000..93c598e
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei64-1.C
@@ -0,0 +1,518 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei64(int8_t* base,vuint64m1_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(int8_t* base,vuint64m2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(int8_t* base,vuint64m4_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(int8_t* base,vuint64m8_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(int16_t* base,vuint64m1_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(int16_t* base,vuint64m2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(int16_t* base,vuint64m4_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(int16_t* base,vuint64m8_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(int32_t* base,vuint64m1_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(int32_t* base,vuint64m2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(int32_t* base,vuint64m4_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(int32_t* base,vuint64m8_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(int64_t* base,vuint64m1_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(int64_t* base,vuint64m2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(int64_t* base,vuint64m4_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(int64_t* base,vuint64m8_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(uint8_t* base,vuint64m1_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(uint8_t* base,vuint64m2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(uint8_t* base,vuint64m4_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(uint8_t* base,vuint64m8_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(uint16_t* base,vuint64m1_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(uint16_t* base,vuint64m2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(uint16_t* base,vuint64m4_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(uint16_t* base,vuint64m8_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(uint32_t* base,vuint64m1_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(uint32_t* base,vuint64m2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(uint32_t* base,vuint64m4_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(uint32_t* base,vuint64m8_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(uint64_t* base,vuint64m1_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(uint64_t* base,vuint64m2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(uint64_t* base,vuint64m4_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(uint64_t* base,vuint64m8_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(float* base,vuint64m1_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(float* base,vuint64m2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(float* base,vuint64m4_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(float* base,vuint64m8_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(double* base,vuint64m1_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(double* base,vuint64m2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(double* base,vuint64m4_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(double* base,vuint64m8_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool64_t mask,int8_t* base,vuint64m1_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool32_t mask,int8_t* base,vuint64m2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool16_t mask,int8_t* base,vuint64m4_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool8_t mask,int8_t* base,vuint64m8_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool64_t mask,int16_t* base,vuint64m1_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool32_t mask,int16_t* base,vuint64m2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool16_t mask,int16_t* base,vuint64m4_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool8_t mask,int16_t* base,vuint64m8_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool64_t mask,int32_t* base,vuint64m1_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool32_t mask,int32_t* base,vuint64m2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool16_t mask,int32_t* base,vuint64m4_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool8_t mask,int32_t* base,vuint64m8_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool64_t mask,int64_t* base,vuint64m1_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool32_t mask,int64_t* base,vuint64m2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool16_t mask,int64_t* base,vuint64m4_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool8_t mask,int64_t* base,vuint64m8_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool64_t mask,uint8_t* base,vuint64m1_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool32_t mask,uint8_t* base,vuint64m2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool16_t mask,uint8_t* base,vuint64m4_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool8_t mask,uint8_t* base,vuint64m8_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool64_t mask,uint16_t* base,vuint64m1_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool32_t mask,uint16_t* base,vuint64m2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool16_t mask,uint16_t* base,vuint64m4_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool8_t mask,uint16_t* base,vuint64m8_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool64_t mask,uint32_t* base,vuint64m1_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool32_t mask,uint32_t* base,vuint64m2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool16_t mask,uint32_t* base,vuint64m4_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool8_t mask,uint32_t* base,vuint64m8_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool64_t mask,uint64_t* base,vuint64m1_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool32_t mask,uint64_t* base,vuint64m2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool16_t mask,uint64_t* base,vuint64m4_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool8_t mask,uint64_t* base,vuint64m8_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool64_t mask,float* base,vuint64m1_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool32_t mask,float* base,vuint64m2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool16_t mask,float* base,vuint64m4_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool8_t mask,float* base,vuint64m8_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool64_t mask,double* base,vuint64m1_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool32_t mask,double* base,vuint64m2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool16_t mask,double* base,vuint64m4_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64(vbool8_t mask,double* base,vuint64m8_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei64-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei64-2.C
new file mode 100644
index 0000000..7dcb7c6
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei64-2.C
@@ -0,0 +1,518 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei64(int8_t* base,vuint64m1_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(int8_t* base,vuint64m2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(int8_t* base,vuint64m4_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(int8_t* base,vuint64m8_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(int16_t* base,vuint64m1_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(int16_t* base,vuint64m2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(int16_t* base,vuint64m4_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(int16_t* base,vuint64m8_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(int32_t* base,vuint64m1_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(int32_t* base,vuint64m2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(int32_t* base,vuint64m4_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(int32_t* base,vuint64m8_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(int64_t* base,vuint64m1_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(int64_t* base,vuint64m2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(int64_t* base,vuint64m4_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(int64_t* base,vuint64m8_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(uint8_t* base,vuint64m1_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(uint8_t* base,vuint64m2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(uint8_t* base,vuint64m4_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(uint8_t* base,vuint64m8_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(uint16_t* base,vuint64m1_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(uint16_t* base,vuint64m2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(uint16_t* base,vuint64m4_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(uint16_t* base,vuint64m8_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(uint32_t* base,vuint64m1_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(uint32_t* base,vuint64m2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(uint32_t* base,vuint64m4_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(uint32_t* base,vuint64m8_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(uint64_t* base,vuint64m1_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(uint64_t* base,vuint64m2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(uint64_t* base,vuint64m4_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(uint64_t* base,vuint64m8_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(float* base,vuint64m1_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(float* base,vuint64m2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(float* base,vuint64m4_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(float* base,vuint64m8_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(double* base,vuint64m1_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(double* base,vuint64m2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(double* base,vuint64m4_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(double* base,vuint64m8_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool64_t mask,int8_t* base,vuint64m1_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool32_t mask,int8_t* base,vuint64m2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool16_t mask,int8_t* base,vuint64m4_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool8_t mask,int8_t* base,vuint64m8_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool64_t mask,int16_t* base,vuint64m1_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool32_t mask,int16_t* base,vuint64m2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool16_t mask,int16_t* base,vuint64m4_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool8_t mask,int16_t* base,vuint64m8_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool64_t mask,int32_t* base,vuint64m1_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool32_t mask,int32_t* base,vuint64m2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool16_t mask,int32_t* base,vuint64m4_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool8_t mask,int32_t* base,vuint64m8_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool64_t mask,int64_t* base,vuint64m1_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool32_t mask,int64_t* base,vuint64m2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool16_t mask,int64_t* base,vuint64m4_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool8_t mask,int64_t* base,vuint64m8_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool64_t mask,uint8_t* base,vuint64m1_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool32_t mask,uint8_t* base,vuint64m2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool16_t mask,uint8_t* base,vuint64m4_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool8_t mask,uint8_t* base,vuint64m8_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool64_t mask,uint16_t* base,vuint64m1_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool32_t mask,uint16_t* base,vuint64m2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool16_t mask,uint16_t* base,vuint64m4_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool8_t mask,uint16_t* base,vuint64m8_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool64_t mask,uint32_t* base,vuint64m1_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool32_t mask,uint32_t* base,vuint64m2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool16_t mask,uint32_t* base,vuint64m4_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool8_t mask,uint32_t* base,vuint64m8_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool64_t mask,uint64_t* base,vuint64m1_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool32_t mask,uint64_t* base,vuint64m2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool16_t mask,uint64_t* base,vuint64m4_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool8_t mask,uint64_t* base,vuint64m8_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool64_t mask,float* base,vuint64m1_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool32_t mask,float* base,vuint64m2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool16_t mask,float* base,vuint64m4_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool8_t mask,float* base,vuint64m8_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool64_t mask,double* base,vuint64m1_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool32_t mask,double* base,vuint64m2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool16_t mask,double* base,vuint64m4_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64(vbool8_t mask,double* base,vuint64m8_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei64-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei64-3.C
new file mode 100644
index 0000000..f38adc8
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei64-3.C
@@ -0,0 +1,518 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei64(int8_t* base,vuint64m1_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(int8_t* base,vuint64m2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(int8_t* base,vuint64m4_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(int8_t* base,vuint64m8_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(int16_t* base,vuint64m1_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(int16_t* base,vuint64m2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(int16_t* base,vuint64m4_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(int16_t* base,vuint64m8_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(int32_t* base,vuint64m1_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(int32_t* base,vuint64m2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(int32_t* base,vuint64m4_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(int32_t* base,vuint64m8_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(int64_t* base,vuint64m1_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(int64_t* base,vuint64m2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(int64_t* base,vuint64m4_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(int64_t* base,vuint64m8_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(uint8_t* base,vuint64m1_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(uint8_t* base,vuint64m2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(uint8_t* base,vuint64m4_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(uint8_t* base,vuint64m8_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(uint16_t* base,vuint64m1_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(uint16_t* base,vuint64m2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(uint16_t* base,vuint64m4_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(uint16_t* base,vuint64m8_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(uint32_t* base,vuint64m1_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(uint32_t* base,vuint64m2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(uint32_t* base,vuint64m4_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(uint32_t* base,vuint64m8_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(uint64_t* base,vuint64m1_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(uint64_t* base,vuint64m2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(uint64_t* base,vuint64m4_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(uint64_t* base,vuint64m8_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(float* base,vuint64m1_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(float* base,vuint64m2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(float* base,vuint64m4_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(float* base,vuint64m8_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(double* base,vuint64m1_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(double* base,vuint64m2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(double* base,vuint64m4_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(double* base,vuint64m8_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool64_t mask,int8_t* base,vuint64m1_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool32_t mask,int8_t* base,vuint64m2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool16_t mask,int8_t* base,vuint64m4_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool8_t mask,int8_t* base,vuint64m8_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool64_t mask,int16_t* base,vuint64m1_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool32_t mask,int16_t* base,vuint64m2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool16_t mask,int16_t* base,vuint64m4_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool8_t mask,int16_t* base,vuint64m8_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool64_t mask,int32_t* base,vuint64m1_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool32_t mask,int32_t* base,vuint64m2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool16_t mask,int32_t* base,vuint64m4_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool8_t mask,int32_t* base,vuint64m8_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool64_t mask,int64_t* base,vuint64m1_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool32_t mask,int64_t* base,vuint64m2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool16_t mask,int64_t* base,vuint64m4_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool8_t mask,int64_t* base,vuint64m8_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool64_t mask,uint8_t* base,vuint64m1_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool32_t mask,uint8_t* base,vuint64m2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool16_t mask,uint8_t* base,vuint64m4_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool8_t mask,uint8_t* base,vuint64m8_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool64_t mask,uint16_t* base,vuint64m1_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool32_t mask,uint16_t* base,vuint64m2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool16_t mask,uint16_t* base,vuint64m4_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool8_t mask,uint16_t* base,vuint64m8_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool64_t mask,uint32_t* base,vuint64m1_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool32_t mask,uint32_t* base,vuint64m2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool16_t mask,uint32_t* base,vuint64m4_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool8_t mask,uint32_t* base,vuint64m8_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool64_t mask,uint64_t* base,vuint64m1_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool32_t mask,uint64_t* base,vuint64m2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool16_t mask,uint64_t* base,vuint64m4_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool8_t mask,uint64_t* base,vuint64m8_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool64_t mask,float* base,vuint64m1_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool32_t mask,float* base,vuint64m2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool16_t mask,float* base,vuint64m4_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool8_t mask,float* base,vuint64m8_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool64_t mask,double* base,vuint64m1_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool32_t mask,double* base,vuint64m2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool16_t mask,double* base,vuint64m4_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64(vbool8_t mask,double* base,vuint64m8_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64(mask,base,bindex,value,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei8-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei8-1.C
new file mode 100644
index 0000000..dc4ff4f
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei8-1.C
@@ -0,0 +1,686 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei8(int8_t* base,vuint8mf8_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(int8_t* base,vuint8mf4_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(int8_t* base,vuint8mf2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(int8_t* base,vuint8m1_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(int8_t* base,vuint8m2_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(int8_t* base,vuint8m4_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(int8_t* base,vuint8m8_t bindex,vint8m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(int16_t* base,vuint8mf8_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(int16_t* base,vuint8mf4_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(int16_t* base,vuint8mf2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(int16_t* base,vuint8m1_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(int16_t* base,vuint8m2_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(int16_t* base,vuint8m4_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(int32_t* base,vuint8mf8_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(int32_t* base,vuint8mf4_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(int32_t* base,vuint8mf2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(int32_t* base,vuint8m1_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(int32_t* base,vuint8m2_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(int64_t* base,vuint8mf8_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(int64_t* base,vuint8mf4_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(int64_t* base,vuint8mf2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(int64_t* base,vuint8m1_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(uint8_t* base,vuint8mf8_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(uint8_t* base,vuint8mf4_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(uint8_t* base,vuint8mf2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(uint8_t* base,vuint8m1_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(uint8_t* base,vuint8m2_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(uint8_t* base,vuint8m4_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(uint8_t* base,vuint8m8_t bindex,vuint8m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(uint16_t* base,vuint8mf8_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(uint16_t* base,vuint8mf4_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(uint16_t* base,vuint8mf2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(uint16_t* base,vuint8m1_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(uint16_t* base,vuint8m2_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(uint16_t* base,vuint8m4_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(uint32_t* base,vuint8mf8_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(uint32_t* base,vuint8mf4_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(uint32_t* base,vuint8mf2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(uint32_t* base,vuint8m1_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(uint32_t* base,vuint8m2_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(uint64_t* base,vuint8mf8_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(uint64_t* base,vuint8mf4_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(uint64_t* base,vuint8mf2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(uint64_t* base,vuint8m1_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(float* base,vuint8mf8_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(float* base,vuint8mf4_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(float* base,vuint8mf2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(float* base,vuint8m1_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(float* base,vuint8m2_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(double* base,vuint8mf8_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(double* base,vuint8mf4_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(double* base,vuint8mf2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(double* base,vuint8m1_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool64_t mask,int8_t* base,vuint8mf8_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool32_t mask,int8_t* base,vuint8mf4_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool16_t mask,int8_t* base,vuint8mf2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool8_t mask,int8_t* base,vuint8m1_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool4_t mask,int8_t* base,vuint8m2_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool2_t mask,int8_t* base,vuint8m4_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool1_t mask,int8_t* base,vuint8m8_t bindex,vint8m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool64_t mask,int16_t* base,vuint8mf8_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool32_t mask,int16_t* base,vuint8mf4_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool16_t mask,int16_t* base,vuint8mf2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool8_t mask,int16_t* base,vuint8m1_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool4_t mask,int16_t* base,vuint8m2_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool2_t mask,int16_t* base,vuint8m4_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool64_t mask,int32_t* base,vuint8mf8_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool32_t mask,int32_t* base,vuint8mf4_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool16_t mask,int32_t* base,vuint8mf2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool8_t mask,int32_t* base,vuint8m1_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool4_t mask,int32_t* base,vuint8m2_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool64_t mask,int64_t* base,vuint8mf8_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool32_t mask,int64_t* base,vuint8mf4_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool16_t mask,int64_t* base,vuint8mf2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool8_t mask,int64_t* base,vuint8m1_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool64_t mask,uint8_t* base,vuint8mf8_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool32_t mask,uint8_t* base,vuint8mf4_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool16_t mask,uint8_t* base,vuint8mf2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool8_t mask,uint8_t* base,vuint8m1_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool4_t mask,uint8_t* base,vuint8m2_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool2_t mask,uint8_t* base,vuint8m4_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool1_t mask,uint8_t* base,vuint8m8_t bindex,vuint8m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool64_t mask,uint16_t* base,vuint8mf8_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool32_t mask,uint16_t* base,vuint8mf4_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool16_t mask,uint16_t* base,vuint8mf2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool8_t mask,uint16_t* base,vuint8m1_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool4_t mask,uint16_t* base,vuint8m2_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool2_t mask,uint16_t* base,vuint8m4_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool64_t mask,uint32_t* base,vuint8mf8_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool32_t mask,uint32_t* base,vuint8mf4_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool16_t mask,uint32_t* base,vuint8mf2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool8_t mask,uint32_t* base,vuint8m1_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool4_t mask,uint32_t* base,vuint8m2_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool64_t mask,uint64_t* base,vuint8mf8_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool32_t mask,uint64_t* base,vuint8mf4_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool16_t mask,uint64_t* base,vuint8mf2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool8_t mask,uint64_t* base,vuint8m1_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool64_t mask,float* base,vuint8mf8_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool32_t mask,float* base,vuint8mf4_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool16_t mask,float* base,vuint8mf2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool8_t mask,float* base,vuint8m1_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool4_t mask,float* base,vuint8m2_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool64_t mask,double* base,vuint8mf8_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool32_t mask,double* base,vuint8mf4_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool16_t mask,double* base,vuint8mf2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8(vbool8_t mask,double* base,vuint8m1_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei8-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei8-2.C
new file mode 100644
index 0000000..f6891ac
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei8-2.C
@@ -0,0 +1,686 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei8(int8_t* base,vuint8mf8_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(int8_t* base,vuint8mf4_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(int8_t* base,vuint8mf2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(int8_t* base,vuint8m1_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(int8_t* base,vuint8m2_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(int8_t* base,vuint8m4_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(int8_t* base,vuint8m8_t bindex,vint8m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(int16_t* base,vuint8mf8_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(int16_t* base,vuint8mf4_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(int16_t* base,vuint8mf2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(int16_t* base,vuint8m1_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(int16_t* base,vuint8m2_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(int16_t* base,vuint8m4_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(int32_t* base,vuint8mf8_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(int32_t* base,vuint8mf4_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(int32_t* base,vuint8mf2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(int32_t* base,vuint8m1_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(int32_t* base,vuint8m2_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(int64_t* base,vuint8mf8_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(int64_t* base,vuint8mf4_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(int64_t* base,vuint8mf2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(int64_t* base,vuint8m1_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(uint8_t* base,vuint8mf8_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(uint8_t* base,vuint8mf4_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(uint8_t* base,vuint8mf2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(uint8_t* base,vuint8m1_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(uint8_t* base,vuint8m2_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(uint8_t* base,vuint8m4_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(uint8_t* base,vuint8m8_t bindex,vuint8m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(uint16_t* base,vuint8mf8_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(uint16_t* base,vuint8mf4_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(uint16_t* base,vuint8mf2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(uint16_t* base,vuint8m1_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(uint16_t* base,vuint8m2_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(uint16_t* base,vuint8m4_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(uint32_t* base,vuint8mf8_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(uint32_t* base,vuint8mf4_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(uint32_t* base,vuint8mf2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(uint32_t* base,vuint8m1_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(uint32_t* base,vuint8m2_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(uint64_t* base,vuint8mf8_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(uint64_t* base,vuint8mf4_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(uint64_t* base,vuint8mf2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(uint64_t* base,vuint8m1_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(float* base,vuint8mf8_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(float* base,vuint8mf4_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(float* base,vuint8mf2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(float* base,vuint8m1_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(float* base,vuint8m2_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(double* base,vuint8mf8_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(double* base,vuint8mf4_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(double* base,vuint8mf2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(double* base,vuint8m1_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool64_t mask,int8_t* base,vuint8mf8_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool32_t mask,int8_t* base,vuint8mf4_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool16_t mask,int8_t* base,vuint8mf2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool8_t mask,int8_t* base,vuint8m1_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool4_t mask,int8_t* base,vuint8m2_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool2_t mask,int8_t* base,vuint8m4_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool1_t mask,int8_t* base,vuint8m8_t bindex,vint8m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool64_t mask,int16_t* base,vuint8mf8_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool32_t mask,int16_t* base,vuint8mf4_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool16_t mask,int16_t* base,vuint8mf2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool8_t mask,int16_t* base,vuint8m1_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool4_t mask,int16_t* base,vuint8m2_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool2_t mask,int16_t* base,vuint8m4_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool64_t mask,int32_t* base,vuint8mf8_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool32_t mask,int32_t* base,vuint8mf4_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool16_t mask,int32_t* base,vuint8mf2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool8_t mask,int32_t* base,vuint8m1_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool4_t mask,int32_t* base,vuint8m2_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool64_t mask,int64_t* base,vuint8mf8_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool32_t mask,int64_t* base,vuint8mf4_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool16_t mask,int64_t* base,vuint8mf2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool8_t mask,int64_t* base,vuint8m1_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool64_t mask,uint8_t* base,vuint8mf8_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool32_t mask,uint8_t* base,vuint8mf4_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool16_t mask,uint8_t* base,vuint8mf2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool8_t mask,uint8_t* base,vuint8m1_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool4_t mask,uint8_t* base,vuint8m2_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool2_t mask,uint8_t* base,vuint8m4_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool1_t mask,uint8_t* base,vuint8m8_t bindex,vuint8m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool64_t mask,uint16_t* base,vuint8mf8_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool32_t mask,uint16_t* base,vuint8mf4_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool16_t mask,uint16_t* base,vuint8mf2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool8_t mask,uint16_t* base,vuint8m1_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool4_t mask,uint16_t* base,vuint8m2_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool2_t mask,uint16_t* base,vuint8m4_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool64_t mask,uint32_t* base,vuint8mf8_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool32_t mask,uint32_t* base,vuint8mf4_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool16_t mask,uint32_t* base,vuint8mf2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool8_t mask,uint32_t* base,vuint8m1_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool4_t mask,uint32_t* base,vuint8m2_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool64_t mask,uint64_t* base,vuint8mf8_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool32_t mask,uint64_t* base,vuint8mf4_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool16_t mask,uint64_t* base,vuint8mf2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool8_t mask,uint64_t* base,vuint8m1_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool64_t mask,float* base,vuint8mf8_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool32_t mask,float* base,vuint8mf4_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool16_t mask,float* base,vuint8mf2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool8_t mask,float* base,vuint8m1_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool4_t mask,float* base,vuint8m2_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool64_t mask,double* base,vuint8mf8_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool32_t mask,double* base,vuint8mf4_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool16_t mask,double* base,vuint8mf2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8(vbool8_t mask,double* base,vuint8m1_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei8-3.C b/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei8-3.C
new file mode 100644
index 0000000..59ff580
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/base/vsuxei8-3.C
@@ -0,0 +1,686 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei8(int8_t* base,vuint8mf8_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(int8_t* base,vuint8mf4_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(int8_t* base,vuint8mf2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(int8_t* base,vuint8m1_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(int8_t* base,vuint8m2_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(int8_t* base,vuint8m4_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(int8_t* base,vuint8m8_t bindex,vint8m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(int16_t* base,vuint8mf8_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(int16_t* base,vuint8mf4_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(int16_t* base,vuint8mf2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(int16_t* base,vuint8m1_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(int16_t* base,vuint8m2_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(int16_t* base,vuint8m4_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(int32_t* base,vuint8mf8_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(int32_t* base,vuint8mf4_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(int32_t* base,vuint8mf2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(int32_t* base,vuint8m1_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(int32_t* base,vuint8m2_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(int64_t* base,vuint8mf8_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(int64_t* base,vuint8mf4_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(int64_t* base,vuint8mf2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(int64_t* base,vuint8m1_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(uint8_t* base,vuint8mf8_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(uint8_t* base,vuint8mf4_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(uint8_t* base,vuint8mf2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(uint8_t* base,vuint8m1_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(uint8_t* base,vuint8m2_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(uint8_t* base,vuint8m4_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(uint8_t* base,vuint8m8_t bindex,vuint8m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(uint16_t* base,vuint8mf8_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(uint16_t* base,vuint8mf4_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(uint16_t* base,vuint8mf2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(uint16_t* base,vuint8m1_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(uint16_t* base,vuint8m2_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(uint16_t* base,vuint8m4_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(uint32_t* base,vuint8mf8_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(uint32_t* base,vuint8mf4_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(uint32_t* base,vuint8mf2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(uint32_t* base,vuint8m1_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(uint32_t* base,vuint8m2_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(uint64_t* base,vuint8mf8_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(uint64_t* base,vuint8mf4_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(uint64_t* base,vuint8mf2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(uint64_t* base,vuint8m1_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(float* base,vuint8mf8_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(float* base,vuint8mf4_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(float* base,vuint8mf2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(float* base,vuint8m1_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(float* base,vuint8m2_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(double* base,vuint8mf8_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(double* base,vuint8mf4_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(double* base,vuint8mf2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(double* base,vuint8m1_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool64_t mask,int8_t* base,vuint8mf8_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool32_t mask,int8_t* base,vuint8mf4_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool16_t mask,int8_t* base,vuint8mf2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool8_t mask,int8_t* base,vuint8m1_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool4_t mask,int8_t* base,vuint8m2_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool2_t mask,int8_t* base,vuint8m4_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool1_t mask,int8_t* base,vuint8m8_t bindex,vint8m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool64_t mask,int16_t* base,vuint8mf8_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool32_t mask,int16_t* base,vuint8mf4_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool16_t mask,int16_t* base,vuint8mf2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool8_t mask,int16_t* base,vuint8m1_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool4_t mask,int16_t* base,vuint8m2_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool2_t mask,int16_t* base,vuint8m4_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool64_t mask,int32_t* base,vuint8mf8_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool32_t mask,int32_t* base,vuint8mf4_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool16_t mask,int32_t* base,vuint8mf2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool8_t mask,int32_t* base,vuint8m1_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool4_t mask,int32_t* base,vuint8m2_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool64_t mask,int64_t* base,vuint8mf8_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool32_t mask,int64_t* base,vuint8mf4_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool16_t mask,int64_t* base,vuint8mf2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool8_t mask,int64_t* base,vuint8m1_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool64_t mask,uint8_t* base,vuint8mf8_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool32_t mask,uint8_t* base,vuint8mf4_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool16_t mask,uint8_t* base,vuint8mf2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool8_t mask,uint8_t* base,vuint8m1_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool4_t mask,uint8_t* base,vuint8m2_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool2_t mask,uint8_t* base,vuint8m4_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool1_t mask,uint8_t* base,vuint8m8_t bindex,vuint8m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool64_t mask,uint16_t* base,vuint8mf8_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool32_t mask,uint16_t* base,vuint8mf4_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool16_t mask,uint16_t* base,vuint8mf2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool8_t mask,uint16_t* base,vuint8m1_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool4_t mask,uint16_t* base,vuint8m2_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool2_t mask,uint16_t* base,vuint8m4_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool64_t mask,uint32_t* base,vuint8mf8_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool32_t mask,uint32_t* base,vuint8mf4_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool16_t mask,uint32_t* base,vuint8mf2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool8_t mask,uint32_t* base,vuint8m1_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool4_t mask,uint32_t* base,vuint8m2_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool64_t mask,uint64_t* base,vuint8mf8_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool32_t mask,uint64_t* base,vuint8mf4_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool16_t mask,uint64_t* base,vuint8mf2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool8_t mask,uint64_t* base,vuint8m1_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool64_t mask,float* base,vuint8mf8_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool32_t mask,float* base,vuint8mf4_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool16_t mask,float* base,vuint8mf2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool8_t mask,float* base,vuint8m1_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool4_t mask,float* base,vuint8m2_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool64_t mask,double* base,vuint8mf8_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool32_t mask,double* base,vuint8mf4_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool16_t mask,double* base,vuint8mf2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8(vbool8_t mask,double* base,vuint8m1_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8(mask,base,bindex,value,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/g++.target/riscv/rvv/rvv.exp b/gcc/testsuite/g++.target/riscv/rvv/rvv.exp
new file mode 100644
index 0000000..2495305
--- /dev/null
+++ b/gcc/testsuite/g++.target/riscv/rvv/rvv.exp
@@ -0,0 +1,44 @@
+# Copyright (C) 2023-2023 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with GCC; see the file COPYING3.  If not see
+# <http://www.gnu.org/licenses/>.
+
+# GCC testsuite that uses the `dg.exp' driver.
+
+# Test the front-end for C++.
+# We don't need to test back-end code-gen in RV32 system for C++
+# Because it is already tested in C.
+# Exit immediately if this isn't a RISC-V target.
+if ![istarget riscv*-*-*] then {
+  return
+}
+
+# Load support procs.
+load_lib g++-dg.exp
+
+set gcc_march "rv64gcv_zfh"
+if [istarget riscv32-*-*] then {
+  set gcc_march "rv32gcv_zfh"
+}
+
+# Initialize `dg'.
+dg-init
+
+# Main loop.
+set CFLAGS "-march=$gcc_march -O3"
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/base/*.C]] \
+	"" $CFLAGS
+
+# All done.
+dg-finish
diff --git a/gcc/testsuite/gcc.c-torture/compile/pr108596.c b/gcc/testsuite/gcc.c-torture/compile/pr108596.c
new file mode 100644
index 0000000..4de6c49
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/pr108596.c
@@ -0,0 +1,26 @@
+/* PR rtl-optimization/108596 */
+
+__attribute__((__cold__)) void foo (void);
+void bar (void);
+
+void
+baz (void)
+{
+  asm goto ("" : : : : l1, l0);
+  goto l0;
+l1:
+  bar ();
+l0:
+  foo ();
+}
+
+void
+qux (void)
+{
+  asm goto ("" : : : : l1, l0);
+  __builtin_unreachable ();
+l1:
+  bar ();
+l0:
+  foo ();
+}
diff --git a/gcc/testsuite/gcc.c-torture/execute/ieee/pr108540-1.c b/gcc/testsuite/gcc.c-torture/execute/ieee/pr108540-1.c
new file mode 100644
index 0000000..ebd4c50
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/execute/ieee/pr108540-1.c
@@ -0,0 +1,84 @@
+/* PR tree-optimization/108540 */
+
+__attribute__((noipa)) void
+bar (const char *cp, unsigned long size, char sign, int dsgn)
+{
+  if (__builtin_strcmp (cp, "ZERO") != 0 || size != 4 || sign != '-' || dsgn != 1)
+    __builtin_abort ();
+}
+
+__attribute__((noipa)) void
+foo (int x, int ch, double d)
+{
+  const char *cp = "";
+  unsigned long size = 0;
+  char sign = '\0';
+  switch (x)
+    {
+    case 42:
+      if (__builtin_isinf (d))
+	{
+	  if (d < 0)
+	    sign = '-';
+	  cp = "Inf";
+	  size = 3;
+	  break;
+	}
+      if (__builtin_isnan (d))
+	{
+	  cp = "NaN";
+	  size = 3;
+	  break;
+	}
+      if (d < 0)
+	{
+	  d = -d;
+	  sign = '-';
+	}
+      else if (d == 0.0 && __builtin_signbit (d))
+	sign = '-';
+      else
+	sign = '\0';
+      if (ch == 'a' || ch == 'A')
+	{
+	  union U { long long l; double d; } u;
+	  int dsgn;
+	  u.d = d;
+	  if (u.l < 0)
+	    {
+	      dsgn = 1;
+	      u.l &= 0x7fffffffffffffffLL;
+	    }
+	  else
+	    dsgn = 0;
+	  if (__builtin_isinf (d))
+	    {
+	      cp = "INF";
+	      size = 3;
+	    }
+	  else if (__builtin_isnan (d))
+	    {
+	      cp = "NAN";
+	      size = 3;
+	    }
+	  else if (d == 0)
+	    {
+	      cp = "ZERO";
+	      size = 4;
+	    }
+	  else
+	    {
+	      cp = "WRONG";
+	      size = 5;
+	    }
+	  bar (cp, size, sign, dsgn);
+	}
+    }
+}
+
+int
+main ()
+{
+  foo (42, 'a', -0.0);
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.c-torture/execute/ieee/pr108540-2.c b/gcc/testsuite/gcc.c-torture/execute/ieee/pr108540-2.c
new file mode 100644
index 0000000..f1b13c9
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/execute/ieee/pr108540-2.c
@@ -0,0 +1,23 @@
+/* PR tree-optimization/108540 */
+
+__attribute__((noipa)) int
+foo (int x, double d)
+{
+  if (x == 42)
+    d = -0.0;
+  if (d == 0.0)
+    return 42;
+  return 12;
+}
+
+int
+main ()
+{
+  if (foo (42, 5.0) != 42
+      || foo (42, 0.0) != 42
+      || foo (42, -0.0) != 42
+      || foo (10, 5.0) != 12
+      || foo (10, 0.0) != 42
+      || foo (10, -0.0) != 42)
+    __builtin_abort ();
+}
diff --git a/gcc/testsuite/gcc.c-torture/execute/pr106523.c b/gcc/testsuite/gcc.c-torture/execute/pr106523.c
new file mode 100644
index 0000000..abd78f5
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/execute/pr106523.c
@@ -0,0 +1,22 @@
+/* PR tree-optimization/106523 */
+
+__attribute__((noipa)) unsigned char
+f7 (unsigned char x, unsigned int y)
+{
+  unsigned int t = x;
+  return (t << y) | (t >> ((-y) & 7));
+}
+
+int
+main ()
+{
+  if (__CHAR_BIT__ != 8 || __SIZEOF_INT__ != 4)
+    return 0;
+
+  volatile unsigned char x = 152;
+  volatile unsigned int y = 19;
+  if (f7 (x, y) != 4)
+    __builtin_abort ();
+
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.c-torture/execute/pr108498-1.c b/gcc/testsuite/gcc.c-torture/execute/pr108498-1.c
new file mode 100644
index 0000000..217c1e4
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/execute/pr108498-1.c
@@ -0,0 +1,82 @@
+/* PR tree-optimization/108498 */
+
+struct A
+{
+  signed char a1;
+  int a2;
+};
+
+struct B
+{
+  struct A b1;
+  unsigned char b2:1, b3:1, b4:2, b5:1, b6:1, b7[4];
+};
+
+struct C
+{
+  unsigned char c1;
+  char c2;
+  signed char c3;
+  unsigned char c4, c5[4], c6:1, c7:1, c8:1, c9:3, c10:1;
+  struct A c11;
+  struct B c12[3];
+};
+
+static inline struct C
+foo (unsigned char a, unsigned b, int c, struct A d,
+     unsigned e, struct B f, struct B g, struct B h)
+{
+  struct C x
+    = { .c1 = b, .c2 = 0, .c3 = c, .c6 = a, .c4 = e, .c7 = 0,
+        .c8 = 0, .c9 = 7, .c10 = 0, .c5 = {0, 1, 2, 3}, .c11 = d,
+        .c12 = {f, g, h} };
+  return x;
+}
+
+static inline struct A
+bar (int a, int b)
+{
+  struct A x = { .a1 = a, .a2 = b };
+  return x;
+}
+
+static inline struct B
+baz (struct A b1)
+{
+  struct B x = { .b1 = b1, .b6 = 0, .b5 = 0, .b7 = {0, 1, 2, 3}, .b2 = 0 };
+  return x;
+}
+
+struct C
+qux (void)
+{
+  const struct B a = baz (bar (0, 0));
+  struct C b;
+  struct B c[2];
+  struct A d = { 0, 1 };
+  c[0].b1.a1 = 0;
+  c[0].b1.a2 = 2;
+  c[1].b1.a1 = 4;
+  c[1].b1.a2 = 8;
+  return foo (0, 2, -1, d, 3, c[0], c[1], a);
+}
+
+__attribute__((noipa)) void
+corge (struct C *x)
+{
+  char buf[1024];
+  __builtin_memset (buf, 0xaa, sizeof (buf));
+  asm volatile ("" : : "r" (buf));
+  __builtin_memset (x, 0x55, sizeof (struct C));
+  asm volatile ("" : : "r" (x));
+}
+
+int
+main ()
+{
+  struct C x;
+  corge (&x);
+  x = qux ();
+  if (x.c6 || x.c9 != 7)
+    __builtin_abort ();
+}
diff --git a/gcc/testsuite/gcc.c-torture/execute/pr108498-2.c b/gcc/testsuite/gcc.c-torture/execute/pr108498-2.c
new file mode 100644
index 0000000..ad93048
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/execute/pr108498-2.c
@@ -0,0 +1,91 @@
+/* PR tree-optimization/108498 */
+
+struct U { char c[16]; };
+struct V { char c[16]; };
+struct S { unsigned int a : 3, b : 8, c : 21; struct U d; unsigned int e; struct V f; unsigned int g : 5, h : 27; };
+struct T { unsigned int a : 16, b : 8, c : 8; struct U d; unsigned int e; struct V f; unsigned int g : 5, h : 27; };
+
+__attribute__((noipa)) void
+foo (struct S *p)
+{
+  p->b = 231;
+  p->c = 42;
+  p->d = (struct U) { "abcdefghijklmno" };
+  p->e = 0xdeadbeef;
+  p->f = (struct V) { "ABCDEFGHIJKLMNO" };
+}
+
+__attribute__((noipa)) void
+bar (struct S *p)
+{
+  p->b = 231;
+  p->c = 42;
+  p->d = (struct U) { "abcdefghijklmno" };
+  p->e = 0xdeadbeef;
+  p->f = (struct V) { "ABCDEFGHIJKLMNO" };
+  p->g = 12;
+}
+
+__attribute__((noipa)) void
+baz (struct T *p)
+{
+  p->c = 42;
+  p->d = (struct U) { "abcdefghijklmno" };
+  p->e = 0xdeadbeef;
+  p->f = (struct V) { "ABCDEFGHIJKLMNO" };
+  p->g = 12;
+}
+
+int
+main ()
+{
+  if (__CHAR_BIT__ != 8 || __SIZEOF_INT__ != 4)
+    return 0;
+  struct S s = {};
+  struct T t = {};
+  foo (&s);
+  if (s.a != 0 || s.b != 231 || s.c != 42
+      || __builtin_memcmp (&s.d.c, "abcdefghijklmno", 16) || s.e != 0xdeadbeef
+      || __builtin_memcmp (&s.f.c, "ABCDEFGHIJKLMNO", 16) || s.g != 0 || s.h != 0)
+    __builtin_abort ();
+  __builtin_memset (&s, 0, sizeof (s));
+  s.a = 7;
+  s.g = 31;
+  s.h = (1U << 27) - 1;
+  foo (&s);
+  if (s.a != 7 || s.b != 231 || s.c != 42
+      || __builtin_memcmp (&s.d.c, "abcdefghijklmno", 16) || s.e != 0xdeadbeef
+      || __builtin_memcmp (&s.f.c, "ABCDEFGHIJKLMNO", 16) || s.g != 31 || s.h != (1U << 27) - 1)
+    __builtin_abort ();
+  __builtin_memset (&s, 0, sizeof (s));
+  bar (&s);
+  if (s.a != 0 || s.b != 231 || s.c != 42
+      || __builtin_memcmp (&s.d.c, "abcdefghijklmno", 16) || s.e != 0xdeadbeef
+      || __builtin_memcmp (&s.f.c, "ABCDEFGHIJKLMNO", 16) || s.g != 12 || s.h != 0)
+    __builtin_abort ();
+  __builtin_memset (&s, 0, sizeof (s));
+  s.a = 7;
+  s.g = 31;
+  s.h = (1U << 27) - 1;
+  bar (&s);
+  if (s.a != 7 || s.b != 231 || s.c != 42
+      || __builtin_memcmp (&s.d.c, "abcdefghijklmno", 16) || s.e != 0xdeadbeef
+      || __builtin_memcmp (&s.f.c, "ABCDEFGHIJKLMNO", 16) || s.g != 12 || s.h != (1U << 27) - 1)
+    __builtin_abort ();
+  baz (&t);
+  if (t.a != 0 || t.b != 0 || t.c != 42
+      || __builtin_memcmp (&t.d.c, "abcdefghijklmno", 16) || t.e != 0xdeadbeef
+      || __builtin_memcmp (&t.f.c, "ABCDEFGHIJKLMNO", 16) || t.g != 12 || t.h != 0)
+    __builtin_abort ();
+  __builtin_memset (&s, 0, sizeof (s));
+  t.a = 7;
+  t.b = 255;
+  t.g = 31;
+  t.h = (1U << 27) - 1;
+  baz (&t);
+  if (t.a != 7 || t.b != 255 || t.c != 42
+      || __builtin_memcmp (&t.d.c, "abcdefghijklmno", 16) || t.e != 0xdeadbeef
+      || __builtin_memcmp (&t.f.c, "ABCDEFGHIJKLMNO", 16) || t.g != 12 || t.h != (1U << 27) - 1)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/analyzer/SARD-tc117-basic-00001-min.c b/gcc/testsuite/gcc.dg/analyzer/SARD-tc117-basic-00001-min.c
new file mode 100644
index 0000000..e1ce195
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/analyzer/SARD-tc117-basic-00001-min.c
@@ -0,0 +1,67 @@
+/* Adapted from https://samate.nist.gov/SARD/test-cases/117/versions/1.0.0
+   Part of https://samate.nist.gov/SARD/test-suites/81
+   See:
+     Black, P. , Koo, H. and Irish, T. (2013), A Basic CWE-121 Buffer Overflow Effectiveness Test Suite, Proc. 6th Latin-American Symposium on Dependable Computing, Rio de Janeiro, -1, [online], https://tsapps.nist.gov/publication/get_pdf.cfm?pub_id=913117 (Accessed January 17, 2023)
+*/
+
+/* Taxonomy Classification: 0000000000000000000100 */
+
+/*
+ *  WRITE/READ               	 0	write
+ *  WHICH BOUND              	 0	upper
+ *  DATA TYPE                	 0	char
+ *  MEMORY LOCATION          	 0	stack
+ *  SCOPE                    	 0	same
+ *  CONTAINER                	 0	no
+ *  POINTER                  	 0	no
+ *  INDEX COMPLEXITY         	 0	constant
+ *  ADDRESS COMPLEXITY       	 0	constant
+ *  LENGTH COMPLEXITY        	 0	N/A
+ *  ADDRESS ALIAS            	 0	none
+ *  INDEX ALIAS              	 0	none
+ *  LOCAL CONTROL FLOW       	 0	none
+ *  SECONDARY CONTROL FLOW   	 0	none
+ *  LOOP STRUCTURE           	 0	no
+ *  LOOP COMPLEXITY          	 0	N/A
+ *  ASYNCHRONY               	 0	no
+ *  TAINT                    	 0	no
+ *  RUNTIME ENV. DEPENDENCE  	 0	no
+ *  MAGNITUDE                	 1	1 byte
+ *  CONTINUOUS/DISCRETE      	 0	discrete
+ *  SIGNEDNESS               	 0	no
+ */
+
+/*
+Copyright 2004 M.I.T.
+
+Permission is hereby granted, without written agreement or royalty fee, to use, 
+copy, modify, and distribute this software and its documentation for any 
+purpose, provided that the above copyright notice and the following three 
+paragraphs appear in all copies of this software.
+
+IN NO EVENT SHALL M.I.T. BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, 
+INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS SOFTWARE 
+AND ITS DOCUMENTATION, EVEN IF M.I.T. HAS BEEN ADVISED OF THE POSSIBILITY OF 
+SUCH DAMANGE.
+
+M.I.T. SPECIFICALLY DISCLAIMS ANY WARRANTIES INCLUDING, BUT NOT LIMITED TO 
+THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, 
+AND NON-INFRINGEMENT.
+
+THE SOFTWARE IS PROVIDED ON AN "AS-IS" BASIS AND M.I.T. HAS NO OBLIGATION TO 
+PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
+*/
+
+
+int main(int argc, char *argv[])
+{
+  char buf[10];
+
+
+  /*  BAD  */
+  buf[10] = 'A'; /* { dg-warning "stack-based buffer overflow" } */
+  /* { dg-message "write of 1 byte to beyond the end of 'buf'" "note" { target *-*-* } .-1 } */
+
+
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/analyzer/SARD-tc1909-stack_overflow_loop.c b/gcc/testsuite/gcc.dg/analyzer/SARD-tc1909-stack_overflow_loop.c
new file mode 100644
index 0000000..2a7612a
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/analyzer/SARD-tc1909-stack_overflow_loop.c
@@ -0,0 +1,29 @@
+/* Adapted from
+     https://samate.nist.gov/SARD/downloads/test-suites/2013-02-07-basic-cwe-effectiveness-cwe-121-stack-based-buffer-overflow-for-c.zip
+   Part of https://samate.nist.gov/SARD/test-suites/81:
+   See:
+     Black, P. , Koo, H. and Irish, T. (2013), A Basic CWE-121 Buffer Overflow Effectiveness Test Suite, Proc. 6th Latin-American Symposium on Dependable Computing, Rio de Janeiro, -1, [online], https://tsapps.nist.gov/publication/get_pdf.cfm?pub_id=913117 (Accessed January 17, 2023)
+*/
+
+/* This software was developed at the National Institute of Standards and
+ * Technology by employees of the Federal Government in the course of their
+ * official duties. Pursuant to title 17 Section 105 of the United States
+ * Code this software is not subject to copyright protection and is in the
+ * public domain. NIST assumes no responsibility whatsoever for its use by
+ * other parties, and makes no guarantees, expressed or implied, about its
+ * quality, reliability, or any other characteristic.
+
+ * We would appreciate acknowledgement if the software is used.
+ * The SAMATE project website is: http://samate.nist.gov
+*/
+
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+	char bStr[10];
+	for (unsigned i=1;i<=10;++i) {
+		bStr[i] = (char)i + 'a'; /* { dg-warning "stack-based buffer overflow" "PR analyzer/108432" { xfail *-*-* } } */
+	}
+	return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/analyzer/SARD-tc249-basic-00034-min.c b/gcc/testsuite/gcc.dg/analyzer/SARD-tc249-basic-00034-min.c
new file mode 100644
index 0000000..4031e6d
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/analyzer/SARD-tc249-basic-00034-min.c
@@ -0,0 +1,67 @@
+/* Adapted from https://samate.nist.gov/SARD/test-cases/249/versions/1.0.0
+   Part of https://samate.nist.gov/SARD/test-suites/81
+   See:
+     Black, P. , Koo, H. and Irish, T. (2013), A Basic CWE-121 Buffer Overflow Effectiveness Test Suite, Proc. 6th Latin-American Symposium on Dependable Computing, Rio de Janeiro, -1, [online], https://tsapps.nist.gov/publication/get_pdf.cfm?pub_id=913117 (Accessed January 17, 2023)
+*/
+
+/* Taxonomy Classification: 0000001600030000000100 */
+
+/*
+ *  WRITE/READ               	 0	write
+ *  WHICH BOUND              	 0	upper
+ *  DATA TYPE                	 0	char
+ *  MEMORY LOCATION          	 0	stack
+ *  SCOPE                    	 0	same
+ *  CONTAINER                	 0	no
+ *  POINTER                  	 1	yes
+ *  INDEX COMPLEXITY         	 6	N/A
+ *  ADDRESS COMPLEXITY       	 0	constant
+ *  LENGTH COMPLEXITY        	 0	N/A
+ *  ADDRESS ALIAS            	 0	none
+ *  INDEX ALIAS              	 3	N/A
+ *  LOCAL CONTROL FLOW       	 0	none
+ *  SECONDARY CONTROL FLOW   	 0	none
+ *  LOOP STRUCTURE           	 0	no
+ *  LOOP COMPLEXITY          	 0	N/A
+ *  ASYNCHRONY               	 0	no
+ *  TAINT                    	 0	no
+ *  RUNTIME ENV. DEPENDENCE  	 0	no
+ *  MAGNITUDE                	 1	1 byte
+ *  CONTINUOUS/DISCRETE      	 0	discrete
+ *  SIGNEDNESS               	 0	no
+ */
+
+/*
+Copyright 2004 M.I.T.
+
+Permission is hereby granted, without written agreement or royalty fee, to use, 
+copy, modify, and distribute this software and its documentation for any 
+purpose, provided that the above copyright notice and the following three 
+paragraphs appear in all copies of this software.
+
+IN NO EVENT SHALL M.I.T. BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, 
+INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS SOFTWARE 
+AND ITS DOCUMENTATION, EVEN IF M.I.T. HAS BEEN ADVISED OF THE POSSIBILITY OF 
+SUCH DAMANGE.
+
+M.I.T. SPECIFICALLY DISCLAIMS ANY WARRANTIES INCLUDING, BUT NOT LIMITED TO 
+THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, 
+AND NON-INFRINGEMENT.
+
+THE SOFTWARE IS PROVIDED ON AN "AS-IS" BASIS AND M.I.T. HAS NO OBLIGATION TO 
+PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
+*/
+
+
+int main(int argc, char *argv[])
+{
+  char buf[10];
+
+
+  /*  BAD  */
+  *(buf + 10) = 'A'; /* { dg-warning "stack-based buffer overflow" } */
+  /* { dg-message "write of 1 byte to beyond the end of 'buf'" "note" { target *-*-* } .-1 } */
+
+
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/analyzer/SARD-tc293-basic-00045-min.c b/gcc/testsuite/gcc.dg/analyzer/SARD-tc293-basic-00045-min.c
new file mode 100644
index 0000000..36c1946
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/analyzer/SARD-tc293-basic-00045-min.c
@@ -0,0 +1,69 @@
+/* Adapted from https://samate.nist.gov/SARD/test-cases/293/versions/1.0.0
+   Part of https://samate.nist.gov/SARD/test-suites/81
+   See:
+     Black, P. , Koo, H. and Irish, T. (2013), A Basic CWE-121 Buffer Overflow Effectiveness Test Suite, Proc. 6th Latin-American Symposium on Dependable Computing, Rio de Janeiro, -1, [online], https://tsapps.nist.gov/publication/get_pdf.cfm?pub_id=913117 (Accessed January 17, 2023)
+*/
+
+/* Taxonomy Classification: 0000300601130000000110 */
+
+/*
+ *  WRITE/READ               	 0	write
+ *  WHICH BOUND              	 0	upper
+ *  DATA TYPE                	 0	char
+ *  MEMORY LOCATION          	 0	stack
+ *  SCOPE                    	 3	inter-file/inter-proc
+ *  CONTAINER                	 0	no
+ *  POINTER                  	 0	no
+ *  INDEX COMPLEXITY         	 6	N/A
+ *  ADDRESS COMPLEXITY       	 0	constant
+ *  LENGTH COMPLEXITY        	 1	none
+ *  ADDRESS ALIAS            	 1	yes, one level
+ *  INDEX ALIAS              	 3	N/A
+ *  LOCAL CONTROL FLOW       	 0	none
+ *  SECONDARY CONTROL FLOW   	 0	none
+ *  LOOP STRUCTURE           	 0	no
+ *  LOOP COMPLEXITY          	 0	N/A
+ *  ASYNCHRONY               	 0	no
+ *  TAINT                    	 0	no
+ *  RUNTIME ENV. DEPENDENCE  	 0	no
+ *  MAGNITUDE                	 1	1 byte
+ *  CONTINUOUS/DISCRETE      	 1	continuous
+ *  SIGNEDNESS               	 0	no
+ */
+
+/*
+Copyright 2004 M.I.T.
+
+Permission is hereby granted, without written agreement or royalty fee, to use, 
+copy, modify, and distribute this software and its documentation for any 
+purpose, provided that the above copyright notice and the following three 
+paragraphs appear in all copies of this software.
+
+IN NO EVENT SHALL M.I.T. BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, 
+INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS SOFTWARE 
+AND ITS DOCUMENTATION, EVEN IF M.I.T. HAS BEEN ADVISED OF THE POSSIBILITY OF 
+SUCH DAMANGE.
+
+M.I.T. SPECIFICALLY DISCLAIMS ANY WARRANTIES INCLUDING, BUT NOT LIMITED TO 
+THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, 
+AND NON-INFRINGEMENT.
+
+THE SOFTWARE IS PROVIDED ON AN "AS-IS" BASIS AND M.I.T. HAS NO OBLIGATION TO 
+PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
+*/
+
+#include <string.h>
+
+int main(int argc, char *argv[])
+{
+  char buf[10];
+
+
+  /*  BAD  */
+  strcpy(buf, "AAAAAAAAAA"); /* { dg-warning "stack-based buffer overflow" "analyzer warning" } */
+  /* { dg-message "write of 1 byte to beyond the end of 'buf'" "analyzer note" { target *-*-* } .-1 } */
+  /* { dg-warning "'__builtin_memcpy' writing 11 bytes into a region of size 10 overflows the destination" "Wstringop-overflow" { target *-*-* } .-2 } */
+
+
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/analyzer/SARD-tc841-basic-00182-min.c b/gcc/testsuite/gcc.dg/analyzer/SARD-tc841-basic-00182-min.c
new file mode 100644
index 0000000..ed9ad31
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/analyzer/SARD-tc841-basic-00182-min.c
@@ -0,0 +1,76 @@
+/* Adapted from https://samate.nist.gov/SARD/test-cases/841/versions/1.0.0
+   Part of https://samate.nist.gov/SARD/test-suites/81
+   See:
+     Black, P. , Koo, H. and Irish, T. (2013), A Basic CWE-121 Buffer Overflow Effectiveness Test Suite, Proc. 6th Latin-American Symposium on Dependable Computing, Rio de Janeiro, -1, [online], https://tsapps.nist.gov/publication/get_pdf.cfm?pub_id=913117 (Accessed January 17, 2023)
+*/
+
+/* The purpose of this testcase is to see if -fanalyzer can detect the bug.  */
+/* { dg-additional-options "-Wno-stringop-overflow" } */
+
+/* Taxonomy Classification: 0000300602130000031110 */
+
+/*
+ *  WRITE/READ               	 0	write
+ *  WHICH BOUND              	 0	upper
+ *  DATA TYPE                	 0	char
+ *  MEMORY LOCATION          	 0	stack
+ *  SCOPE                    	 3	inter-file/inter-proc
+ *  CONTAINER                	 0	no
+ *  POINTER                  	 0	no
+ *  INDEX COMPLEXITY         	 6	N/A
+ *  ADDRESS COMPLEXITY       	 0	constant
+ *  LENGTH COMPLEXITY        	 2	constant
+ *  ADDRESS ALIAS            	 1	yes, one level
+ *  INDEX ALIAS              	 3	N/A
+ *  LOCAL CONTROL FLOW       	 0	none
+ *  SECONDARY CONTROL FLOW   	 0	none
+ *  LOOP STRUCTURE           	 0	no
+ *  LOOP COMPLEXITY          	 0	N/A
+ *  ASYNCHRONY               	 0	no
+ *  TAINT                    	 3	file read
+ *  RUNTIME ENV. DEPENDENCE  	 1	yes
+ *  MAGNITUDE                	 1	1 byte
+ *  CONTINUOUS/DISCRETE      	 1	continuous
+ *  SIGNEDNESS               	 0	no
+ */
+
+/*
+Copyright 2004 M.I.T.
+
+Permission is hereby granted, without written agreement or royalty fee, to use, 
+copy, modify, and distribute this software and its documentation for any 
+purpose, provided that the above copyright notice and the following three 
+paragraphs appear in all copies of this software.
+
+IN NO EVENT SHALL M.I.T. BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, 
+INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS SOFTWARE 
+AND ITS DOCUMENTATION, EVEN IF M.I.T. HAS BEEN ADVISED OF THE POSSIBILITY OF 
+SUCH DAMANGE.
+
+M.I.T. SPECIFICALLY DISCLAIMS ANY WARRANTIES INCLUDING, BUT NOT LIMITED TO 
+THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, 
+AND NON-INFRINGEMENT.
+
+THE SOFTWARE IS PROVIDED ON AN "AS-IS" BASIS AND M.I.T. HAS NO OBLIGATION TO 
+PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
+*/
+
+#include <assert.h>
+#include <stdio.h>
+
+int main(int argc, char *argv[])
+{
+  FILE * f;
+  char buf[10];
+
+  f = fopen("TestInputFile1", "r");
+  assert(f != NULL);
+
+  /*  BAD  */
+  fgets(buf, 11, f); /* { dg-warning "stack-based buffer overflow" "PR analyzer/105895" { xfail *-*-* } } */
+
+  fclose(f);
+
+
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/analyzer/deref-before-check-1.c b/gcc/testsuite/gcc.dg/analyzer/deref-before-check-1.c
index e1c7a00..1b11da5 100644
--- a/gcc/testsuite/gcc.dg/analyzer/deref-before-check-1.c
+++ b/gcc/testsuite/gcc.dg/analyzer/deref-before-check-1.c
@@ -167,3 +167,39 @@ int test_checking_ptr_after_calling_deref (int *q)
     return 0;
   return v;
 }
+
+extern void foo ();
+extern void bar ();
+extern void baz ();
+
+int test_cfg_diamond_1 (int *p, int flag)
+{
+  int x;
+  x = *p; /* { dg-message "pointer 'p' is dereferenced here" } */
+  if (flag)
+    foo ();
+  else
+    bar ();
+  if (p) /* { dg-warning "check of 'p' for NULL after already dereferencing it" } */
+    {
+      baz ();
+    }
+  return x;
+}
+
+int test_cfg_diamond_2 (int *p, int flag)
+{
+  int x = 0;
+  if (flag)
+    foo ();
+  else
+    {
+      x = *p;
+      bar ();
+    }
+  if (p) /* { dg-bogus "check of 'p' for NULL after already dereferencing it" } */
+    {
+      baz ();
+    }
+  return x;
+}
diff --git a/gcc/testsuite/gcc.dg/analyzer/deref-before-check-pr108455-1.c b/gcc/testsuite/gcc.dg/analyzer/deref-before-check-pr108455-1.c
new file mode 100644
index 0000000..d7d873e
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/analyzer/deref-before-check-pr108455-1.c
@@ -0,0 +1,36 @@
+extern int could_fail_1 (void);
+extern void *could_fail_2 (int);
+extern void cleanup (void *);
+
+struct header {
+  int signature;
+};
+
+int test_1 (void) {
+  int fd, ret = 0;
+  void *data = ((void *)0);
+  struct header *hdr;
+
+  fd = could_fail_1 ();
+
+  if (fd < 0) {
+    ret = -1;
+    goto cleanup;
+  }
+
+  data = could_fail_2 (fd);
+  hdr = data;
+
+  if (hdr->signature != 42) {
+    ret = -2;
+    goto cleanup;
+  }
+
+cleanup:
+  if (ret) {
+    if (data) /* { dg-bogus "check of 'data' for NULL after already dereferencing it" } */
+      cleanup (data);
+  }
+
+  return ret;
+}
diff --git a/gcc/testsuite/gcc.dg/analyzer/deref-before-check-pr108455-git-pack-revindex.c b/gcc/testsuite/gcc.dg/analyzer/deref-before-check-pr108455-git-pack-revindex.c
new file mode 100644
index 0000000..7553f86
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/analyzer/deref-before-check-pr108455-git-pack-revindex.c
@@ -0,0 +1,133 @@
+/* Reduced from git-2.39.0's pack-revindex.c  */
+
+typedef unsigned int __uint32_t;
+typedef unsigned long int __uintmax_t;
+typedef long int __off_t;
+typedef long int __off64_t;
+typedef __SIZE_TYPE__ size_t;
+typedef __off64_t off_t;
+typedef __uint32_t uint32_t;
+typedef __uintmax_t uintmax_t;
+
+struct stat {
+  /* [...snip...] */
+  __off_t st_size;
+  /* [...snip...] */
+};
+
+extern int close(int __fd);
+extern int fstat(int __fd, struct stat *__buf)
+  __attribute__((__nothrow__, __leaf__)) __attribute__((__nonnull__(2)));
+extern uint32_t default_swab32(uint32_t val);
+extern uint32_t git_bswap32(uint32_t x);
+__attribute__((__noreturn__)) void die(const char *err, ...)
+    __attribute__((format(printf, 1, 2)));
+int error(const char *err, ...) __attribute__((format(printf, 1, 2)));
+int error_errno(const char *err, ...) __attribute__((format(printf, 1, 2)));
+static inline int const_error(void) { return -1; }
+extern int munmap(void *__addr, size_t __len)
+    __attribute__((__nothrow__, __leaf__));
+extern size_t st_mult(size_t a, size_t b);
+extern void *xmmap(void *start, size_t length, int prot, int flags, int fd,
+		   off_t offset);
+extern size_t xsize_t(off_t len);
+
+extern char *gettext(const char *__msgid) __attribute__((__nothrow__, __leaf__))
+__attribute__((__format_arg__(1)));
+static inline __attribute__((format_arg(1))) const char *_(const char *msgid) {
+  if (!*msgid)
+    return "";
+  return gettext(msgid);
+}
+
+struct repository {
+  /* [...snip...] */
+  const struct git_hash_algo *hash_algo;
+  /* [...snip...] */
+};
+extern struct repository *the_repository;
+struct git_hash_algo {
+  /* [...snip...] */
+  size_t rawsz;
+  /* [...snip...] */
+};
+
+int git_open_cloexec(const char *name, int flags);
+
+struct revindex_header {
+  uint32_t signature;
+  uint32_t version;
+  uint32_t hash_id;
+};
+
+int load_revindex_from_disk(char *revindex_name, uint32_t num_objects,
+                            const uint32_t **data_p, size_t *len_p) {
+  int fd, ret = 0;
+  struct stat st;
+  void *data = ((void *)0);
+  size_t revindex_size;
+  struct revindex_header *hdr;
+
+  fd = git_open_cloexec(revindex_name, 00);
+
+  if (fd < 0) {
+    ret = -1;
+    goto cleanup;
+  }
+  if (fstat(fd, &st)) {
+    ret = (error_errno(_("failed to read %s"), revindex_name), const_error());
+    goto cleanup;
+  }
+
+  revindex_size = xsize_t(st.st_size);
+
+  if (revindex_size < ((12) + (2 * the_repository->hash_algo->rawsz))) {
+    ret = (error(_("reverse-index file %s is too small"), revindex_name),
+           const_error());
+    goto cleanup;
+  }
+
+  if (revindex_size - ((12) + (2 * the_repository->hash_algo->rawsz)) !=
+      st_mult(sizeof(uint32_t), num_objects)) {
+    ret = (error(_("reverse-index file %s is corrupt"), revindex_name),
+           const_error());
+    goto cleanup;
+  }
+
+  data = xmmap(((void *)0), revindex_size, 0x1, 0x02, fd, 0);
+  hdr = data;
+
+  if (git_bswap32(hdr->signature) != 0x52494458) {
+    ret =
+        (error(_("reverse-index file %s has unknown signature"), revindex_name),
+         const_error());
+    goto cleanup;
+  }
+  if (git_bswap32(hdr->version) != 1) {
+    ret = (error(_("reverse-index file %s has unsupported version %"
+                   "u"),
+                 revindex_name, git_bswap32(hdr->version)),
+           const_error());
+    goto cleanup;
+  }
+  if (!(git_bswap32(hdr->hash_id) == 1 || git_bswap32(hdr->hash_id) == 2)) {
+    ret = (error(_("reverse-index file %s has unsupported hash id %"
+                   "u"),
+                 revindex_name, git_bswap32(hdr->hash_id)),
+           const_error());
+    goto cleanup;
+  }
+
+cleanup:
+  if (ret) {
+    if (data) /* { dg-bogus "check of 'data' for NULL after already dereferencing it" } */
+      munmap(data, revindex_size);
+  } else {
+    *len_p = revindex_size;
+    *data_p = (const uint32_t *)data;
+  }
+
+  if (fd >= 0)
+    close(fd);
+  return ret;
+}
diff --git a/gcc/testsuite/gcc.dg/analyzer/infinite-recursion-pr108524-1.c b/gcc/testsuite/gcc.dg/analyzer/infinite-recursion-pr108524-1.c
new file mode 100644
index 0000000..d9221fa8
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/analyzer/infinite-recursion-pr108524-1.c
@@ -0,0 +1,145 @@
+/* Reduced from qemu-7.2.0's qobject/json-parser.c, which
+   is licensed under LGPLv2.1 or later.  */
+
+/* { dg-additional-options "-fno-analyzer-call-summaries -Wno-analyzer-too-complex" } */
+
+#define NULL ((void *)0)
+typedef __builtin_va_list va_list;
+
+typedef struct _GQueue GQueue;
+typedef struct Error Error;
+typedef struct QList QList;
+typedef struct QObject QObject;
+
+struct QObjectBase_ {
+  /* [...snip...] */
+};
+
+
+struct QObject {
+  struct QObjectBase_ base;
+};
+
+#define QOBJECT(obj) ((QObject *)obj)
+#define qobject_unref(OBJ) /* [...snip...] */
+
+typedef struct QTailQLink {
+  void *tql_next;
+  struct QTailQLink *tql_prev;
+} QTailQLink;
+
+struct QList {
+  struct QObjectBase_ base;
+  union {
+    struct QListEntry *tqh_first;
+    QTailQLink tqh_circ;
+  } head;
+};
+QList *qlist_new(void);
+void qlist_append_obj(QList *qlist, QObject *obj);
+
+typedef enum json_token_type {
+  /* [...snip...] */			      
+  JSON_LSQUARE,
+  JSON_RSQUARE,
+  /* [...snip...] */			      
+  JSON_COMMA,
+  /* [...snip...] */			      
+  JSON_KEYWORD,
+  /* [...snip...] */			      
+} JSONTokenType;
+typedef struct JSONToken JSONToken;
+
+struct JSONToken {
+  JSONTokenType type;
+  int x;
+  int y;
+  char str[];
+};
+
+typedef struct JSONParserContext {
+  Error *err;
+  JSONToken *current;
+  GQueue *buf;
+  va_list *ap;
+} JSONParserContext;
+static QObject *parse_value(JSONParserContext *ctxt);
+
+JSONToken *parser_context_pop_token(JSONParserContext *ctxt);
+JSONToken *parser_context_peek_token(JSONParserContext *ctxt);
+
+static QObject *parse_array(JSONParserContext *ctxt) {
+  QList *list = NULL;
+  JSONToken *token, *peek;
+
+  token = parser_context_pop_token(ctxt);
+
+  list = qlist_new();
+
+  peek = parser_context_peek_token(ctxt);
+  if (peek == NULL) {
+    goto out;
+  }
+
+  if (peek->type != JSON_RSQUARE) {
+    QObject *obj;
+
+    obj = parse_value(ctxt); /* { dg-bogus "infinite recursion" } */
+    if (obj == NULL) {
+      goto out;
+    }
+
+    qlist_append_obj(list, obj);
+
+    token = parser_context_pop_token(ctxt);
+    if (token == NULL) {
+      goto out;
+    }
+
+    while (token->type != JSON_RSQUARE) {
+      if (token->type != JSON_COMMA) {
+        goto out;
+      }
+
+      obj = parse_value(ctxt);
+      if (obj == NULL) {
+        goto out;
+      }
+
+      qlist_append_obj(list, obj);
+
+      token = parser_context_pop_token(ctxt);
+      if (token == NULL) {
+        goto out;
+      }
+    }
+  } else {
+    (void)parser_context_pop_token(ctxt);
+  }
+
+  return QOBJECT(list);
+
+out:
+  qobject_unref(list);
+  return NULL;
+}
+
+QObject *parse_keyword(JSONParserContext *ctxt);
+
+QObject *parse_value(JSONParserContext *ctxt) {
+  JSONToken *token;
+
+  token = parser_context_peek_token(ctxt);
+  if (token == NULL) {
+    return NULL;
+  }
+
+  switch (token->type) {
+  case JSON_LSQUARE:
+    return parse_array(ctxt); /* { dg-bogus "infinite recursion" } */
+  case JSON_KEYWORD:
+    return parse_keyword(ctxt);
+  default:
+    return NULL;
+  }
+}
diff --git a/gcc/testsuite/gcc.dg/analyzer/infinite-recursion-pr108524-2.c b/gcc/testsuite/gcc.dg/analyzer/infinite-recursion-pr108524-2.c
new file mode 100644
index 0000000..58f6d2f
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/analyzer/infinite-recursion-pr108524-2.c
@@ -0,0 +1,113 @@
+struct st1;
+
+int foo (struct st1 *p);
+int bar (struct st1 *p);
+
+void test_1 (struct st1 *p)
+{
+  test_1 (p); /* { dg-warning "infinite recursion" } */
+}
+
+void test_2_if (struct st1 *p)
+{
+  if (foo (p))
+    test_2_if (p); /* { dg-bogus "infinite recursion" } */
+}
+
+void test_2_switch (struct st1 *p)
+{
+  switch (foo (p))
+    {
+    case 0 ... 9:
+      test_2_switch (p); /* { dg-bogus "infinite recursion" } */
+      break;
+    default:
+      break;
+    }
+}
+
+void test_2_if_compound (struct st1 *p)
+{
+  if ((foo (p) + bar (p)) >= 0)
+    test_2_if_compound (p); /* { dg-bogus "infinite recursion" } */
+}
+
+void test_3 (struct st1 *p)
+{
+  foo (p);
+  test_3 (p); /* { dg-warning "infinite recursion" } */
+  /* The content of *p never affects control flow, so we should
+     report this.  */
+}
+
+struct st2
+{
+  int i;
+};
+
+void test_4 (struct st2 *p)
+{
+  if (p->i > 0)
+    test_4 (p); /* { dg-warning "infinite recursion" } */
+}
+
+void test_5 (struct st2 *p)
+{
+  if (p->i-- > 0)
+    test_5 (p); /* { dg-bogus "infinite recursion" } */
+}
+
+/* Mixtures of heap allocation and recursion.  It's not clear what we
+   should do for such cases, but make sure we don't ICE.  */
+
+void test_6 (struct st2 *p)
+{
+  struct st2 *q = __builtin_malloc (p->i);
+  if (!q)
+    return;
+  q->i = p->i;
+  test_6 (q);
+  __builtin_free (q);
+}
+
+void test_7 (struct st2 *p)
+{
+  struct st2 *q = __builtin_malloc (p->i);
+  q->i = p->i; /* { dg-warning "dereference of possibly-NULL 'q'" } */
+  test_7 (q);
+  __builtin_free (q);
+}
+
+void test_switch_1 (int i)
+{
+  int j;
+  switch (i)
+    {
+    case 0:
+      j = 1066;
+      break;
+    case 1:
+      j = 1776;
+      break;
+    default:
+      j = 1492;
+      break;
+    }
+  test_switch_1 (j);  /* { dg-warning "infinite recursion" "" { xfail *-*-* } } */
+}
+
+void test_switch_2 (int i)
+{
+  switch (i)
+    {
+    case 0:
+      test_switch_2 (1066);
+      break;
+    case 1:
+      test_switch_2 (1776);
+      break;
+    default:
+      test_switch_2 (1492); /* { dg-warning "infinite recursion" "" { xfail *-*-* } } */
+      break;
+    }
+}
diff --git a/gcc/testsuite/gcc.dg/analyzer/infinite-recursion-pr108524-qobject-json-parser.c b/gcc/testsuite/gcc.dg/analyzer/infinite-recursion-pr108524-qobject-json-parser.c
new file mode 100644
index 0000000..b40326f
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/analyzer/infinite-recursion-pr108524-qobject-json-parser.c
@@ -0,0 +1,322 @@
+/* Reduced from qemu-7.2.0's qobject/json-parser.c, which
+   is licensed under LGPLv2.1 or later.  */
+
+/* { dg-additional-options "-fno-analyzer-call-summaries -Wno-analyzer-too-complex" } */
+
+#define NULL ((void *)0)
+typedef __builtin_va_list va_list;
+typedef __SIZE_TYPE__ size_t;
+
+typedef struct _GString GString;
+typedef struct _GQueue GQueue;
+typedef struct Error Error;
+typedef struct QDict QDict;
+typedef struct QList QList;
+typedef struct QObject QObject;
+typedef struct QString QString;
+
+typedef enum QType {
+  /* [...snip...] */
+  QTYPE_QSTRING,
+  /* [...snip...] */
+} QType;
+
+struct QObjectBase_ {
+  QType type;
+};
+
+struct QObject {
+  struct QObjectBase_ base;
+};
+
+#define QOBJECT(obj) ((QObject *)obj)
+#define qobject_unref(OBJ) /* [...snip...] */
+
+void qobject_ref_impl(QObject *obj);
+QType qobject_type(const QObject *obj);
+QObject *qobject_check_type(const QObject *obj, QType type);
+
+typedef struct QTailQLink {
+  void *tql_next;
+  struct QTailQLink *tql_prev;
+} QTailQLink;
+
+typedef struct QDictEntry {
+  char *key;
+  QObject *value;
+  struct {
+    struct QDictEntry *le_next;
+    struct QDictEntry **le_prev;
+  } next;
+} QDictEntry;
+
+struct QDict {
+  struct QObjectBase_ base;
+  size_t size;
+  struct {
+    struct QDictEntry *lh_first;
+  } table[512];
+};
+
+QDict *qdict_new(void);
+void qdict_put_obj(QDict *qdict, const char *key, QObject *value);
+int qdict_haskey(const QDict *qdict, const char *key);
+typedef struct QListEntry {
+  QObject *value;
+  union {
+    struct QListEntry *tqe_next;
+    QTailQLink tqe_circ;
+  } next;
+} QListEntry;
+
+struct QList {
+  struct QObjectBase_ base;
+  union {
+    struct QListEntry *tqh_first;
+    QTailQLink tqh_circ;
+  } head;
+};
+QList *qlist_new(void);
+void qlist_append_obj(QList *qlist, QObject *obj);
+
+struct QString {
+  struct QObjectBase_ base;
+  const char *string;
+};
+QString *qstring_from_str(const char *str);
+const char *qstring_get_str(const QString *qstring);
+
+typedef enum json_token_type {
+  JSON_ERROR = 0,
+
+  JSON_LCURLY = 100,
+  JSON_MIN = JSON_LCURLY,
+  JSON_RCURLY,
+  JSON_LSQUARE,
+  JSON_RSQUARE,
+  JSON_COLON,
+  JSON_COMMA,
+  JSON_INTEGER,
+  JSON_FLOAT,
+  JSON_KEYWORD,
+  JSON_STRING,
+  JSON_INTERP,
+  JSON_END_OF_INPUT,
+  JSON_MAX = JSON_END_OF_INPUT
+} JSONTokenType;
+typedef struct JSONToken JSONToken;
+
+struct JSONToken {
+  JSONTokenType type;
+  int x;
+  int y;
+  char str[];
+};
+
+typedef struct JSONParserContext {
+  Error *err;
+  JSONToken *current;
+  GQueue *buf;
+  va_list *ap;
+} JSONParserContext;
+static QObject *parse_value(JSONParserContext *ctxt);
+
+void __attribute__((__format__(gnu_printf, 3, 4)))
+parse_error(JSONParserContext *ctxt, JSONToken *token, const char *msg, ...);
+
+JSONToken *parser_context_pop_token(JSONParserContext *ctxt);
+JSONToken *parser_context_peek_token(JSONParserContext *ctxt);
+
+static int parse_pair(JSONParserContext *ctxt, QDict *dict) {
+  QObject *key_obj = NULL;
+  QString *key;
+  QObject *value;
+  JSONToken *peek, *token;
+
+  peek = parser_context_peek_token(ctxt);
+  if (peek == NULL) {
+    parse_error(ctxt, NULL, "premature EOI");
+    goto out;
+  }
+
+  key_obj = parse_value(ctxt); /* { dg-bogus "infinite recursion" } */
+  key = ((QString *)qobject_check_type(key_obj, QTYPE_QSTRING));
+  if (!key) {
+    parse_error(ctxt, peek, "key is not a string in object");
+    goto out;
+  }
+
+  token = parser_context_pop_token(ctxt);
+  if (token == NULL) {
+    parse_error(ctxt, NULL, "premature EOI");
+    goto out;
+  }
+
+  if (token->type != JSON_COLON) {
+    parse_error(ctxt, token, "missing : in object pair");
+    goto out;
+  }
+
+  value = parse_value(ctxt);
+  if (value == NULL) {
+    parse_error(ctxt, token, "Missing value in dict");
+    goto out;
+  }
+
+  if (qdict_haskey(dict, qstring_get_str(key))) {
+    parse_error(ctxt, token, "duplicate key");
+    goto out;
+  }
+
+  qdict_put_obj(dict, qstring_get_str(key), value);
+
+  qobject_unref(key_obj);
+  return 0;
+
+out:
+  qobject_unref(key_obj);
+  return -1;
+}
+
+static QObject *parse_object(JSONParserContext *ctxt) {
+  QDict *dict = NULL;
+  JSONToken *token, *peek;
+
+  token = parser_context_pop_token(ctxt);
+
+  dict = qdict_new();
+
+  peek = parser_context_peek_token(ctxt);
+  if (peek == NULL) {
+    parse_error(ctxt, NULL, "premature EOI");
+    goto out;
+  }
+
+  if (peek->type != JSON_RCURLY) {
+    if (parse_pair(ctxt, dict) == -1) {
+      goto out;
+    }
+
+    token = parser_context_pop_token(ctxt);
+    if (token == NULL) {
+      parse_error(ctxt, NULL, "premature EOI");
+      goto out;
+    }
+
+    while (token->type != JSON_RCURLY) {
+      if (token->type != JSON_COMMA) {
+        parse_error(ctxt, token, "expected separator in dict");
+        goto out;
+      }
+
+      if (parse_pair(ctxt, dict) == -1) {
+        goto out;
+      }
+
+      token = parser_context_pop_token(ctxt);
+      if (token == NULL) {
+        parse_error(ctxt, NULL, "premature EOI");
+        goto out;
+      }
+    }
+  } else {
+    (void)parser_context_pop_token(ctxt);
+  }
+
+  return QOBJECT(dict);
+
+out:
+  qobject_unref (dict);
+  return NULL;
+}
+
+static QObject *parse_array(JSONParserContext *ctxt) {
+  QList *list = NULL;
+  JSONToken *token, *peek;
+
+  token = parser_context_pop_token(ctxt);
+
+  list = qlist_new();
+
+  peek = parser_context_peek_token(ctxt);
+  if (peek == NULL) {
+    parse_error(ctxt, NULL, "premature EOI");
+    goto out;
+  }
+
+  if (peek->type != JSON_RSQUARE) {
+    QObject *obj;
+
+    obj = parse_value(ctxt); /* { dg-bogus "infinite recursion" } */
+    if (obj == NULL) {
+      parse_error(ctxt, token, "expecting value");
+      goto out;
+    }
+
+    qlist_append_obj(list, obj);
+
+    token = parser_context_pop_token(ctxt);
+    if (token == NULL) {
+      parse_error(ctxt, NULL, "premature EOI");
+      goto out;
+    }
+
+    while (token->type != JSON_RSQUARE) {
+      if (token->type != JSON_COMMA) {
+        parse_error(ctxt, token, "expected separator in list");
+        goto out;
+      }
+
+      obj = parse_value(ctxt);
+      if (obj == NULL) {
+        parse_error(ctxt, token, "expecting value");
+        goto out;
+      }
+
+      qlist_append_obj(list, obj);
+
+      token = parser_context_pop_token(ctxt);
+      if (token == NULL) {
+        parse_error(ctxt, NULL, "premature EOI");
+        goto out;
+      }
+    }
+  } else {
+    (void)parser_context_pop_token(ctxt);
+  }
+
+  return QOBJECT(list);
+
+out:
+  qobject_unref(list);
+  return NULL;
+}
+
+QObject *parse_keyword(JSONParserContext *ctxt);
+QObject *parse_literal(JSONParserContext *ctxt);
+
+QObject *parse_value(JSONParserContext *ctxt) {
+  JSONToken *token;
+
+  token = parser_context_peek_token(ctxt);
+  if (token == NULL) {
+    parse_error(ctxt, NULL, "premature EOI");
+    return NULL;
+  }
+
+  switch (token->type) {
+  case JSON_LCURLY:
+    return parse_object(ctxt); /* { dg-bogus "infinite recursion" } */
+  case JSON_LSQUARE:
+    return parse_array(ctxt); /* { dg-bogus "infinite recursion" } */
+  case JSON_INTEGER:
+  case JSON_FLOAT:
+  case JSON_STRING:
+    return parse_literal(ctxt);
+  case JSON_KEYWORD:
+    return parse_keyword(ctxt);
+  default:
+    parse_error(ctxt, token, "expecting value");
+    return NULL;
+  }
+}
diff --git a/gcc/testsuite/gcc.dg/attr-aligned.c b/gcc/testsuite/gcc.dg/attr-aligned.c
index a2e11c9..887bdd0 100644
--- a/gcc/testsuite/gcc.dg/attr-aligned.c
+++ b/gcc/testsuite/gcc.dg/attr-aligned.c
@@ -22,6 +22,9 @@
 #  define ALIGN_MAX_STATIC      2
 /* Work around a pdp11 ICE (see PR target/87821).  */
 #  define ALIGN_MAX_AUTO        (ALIGN_MAX_HARD >> 14)
+#elif __WIN32__ || __CYGWIN__
+#  define ALIGN_MAX_STATIC      8192
+#  define ALIGN_MAX_AUTO        8192
 #elif __powerpc64__ || __x86_64__
 /* Is this processor- or operating-system specific?  */
 #  define ALIGN_MAX_STATIC      ALIGN_MAX_HARD
diff --git a/gcc/testsuite/gcc.dg/builtin-dynamic-object-size-0.c b/gcc/testsuite/gcc.dg/builtin-dynamic-object-size-0.c
index f9047a0..76079d8 100644
--- a/gcc/testsuite/gcc.dg/builtin-dynamic-object-size-0.c
+++ b/gcc/testsuite/gcc.dg/builtin-dynamic-object-size-0.c
@@ -314,6 +314,71 @@ test_dynarray_struct_subobj2 (size_t sz, size_t off, size_t *objsz)
   return __builtin_dynamic_object_size (&bin.c[off], 1);
 }
 
+/* See pr #108522.  */
+
+#define DEFSTRUCT(_s, _n) \
+  struct DS								      \
+    {									      \
+      char a[_n];							      \
+      unsigned long long b;						      \
+      int c;								      \
+      char d[2 * _n];							      \
+    } _s
+
+size_t
+__attribute__ ((noinline))
+test_dynarray_struct_member_b (size_t sz)
+{
+  DEFSTRUCT (s, sz);
+
+  return __builtin_dynamic_object_size (&s.b, 0);
+}
+
+size_t
+__attribute__ ((noinline))
+test_dynarray_struct_member_c (size_t sz)
+{
+  DEFSTRUCT (s, sz);
+
+  return __builtin_dynamic_object_size (&s.c, 0);
+}
+
+size_t
+__attribute__ ((noinline))
+test_dynarray_struct_member_d (size_t sz, size_t offset)
+{
+  DEFSTRUCT (s, sz);
+
+  return __builtin_dynamic_object_size (&s.d[offset], 0);
+}
+
+size_t
+__attribute__ ((noinline))
+test_dynarray_struct_member_subobj_b (size_t sz)
+{
+  DEFSTRUCT (s, sz);
+
+  return __builtin_dynamic_object_size (&s.b, 1);
+}
+
+size_t
+__attribute__ ((noinline))
+test_dynarray_struct_member_subobj_c (size_t sz)
+{
+  DEFSTRUCT (s, sz);
+
+  return __builtin_dynamic_object_size (&s.c, 1);
+}
+
+size_t
+__attribute__ ((noinline))
+test_dynarray_struct_member_subobj_d (size_t sz, size_t offset)
+{
+  DEFSTRUCT (s, sz);
+
+  return __builtin_dynamic_object_size (&s.d[offset], 1);
+}
+
 size_t
 __attribute__ ((noinline))
 test_substring (size_t sz, size_t off)
@@ -619,6 +684,24 @@ main (int argc, char **argv)
   if (test_dynarray_struct_subobj2 (42, 4, &objsz)
     != objsz - 4 - sizeof (long) - sizeof (int))
     FAIL ();
+  DEFSTRUCT(ds, 64);
+  const size_t n = sizeof (ds.a);
+  if (test_dynarray_struct_member_b (n)
+      != sizeof (ds) - __builtin_offsetof (struct DS, b))
+    FAIL ();
+  if (test_dynarray_struct_member_c (n)
+      != sizeof (ds) - __builtin_offsetof (struct DS, c))
+    FAIL ();
+  if (test_dynarray_struct_member_d (n, 0)
+      != sizeof (ds) - __builtin_offsetof (struct DS, d))
+    FAIL ();
+  if (test_dynarray_struct_member_subobj_b (n) != sizeof (ds.b))
+    FAIL ();
+  if (test_dynarray_struct_member_subobj_c (n) != sizeof (ds.c))
+    FAIL ();
+  if (test_dynarray_struct_member_subobj_d (n, n - 2)
+      != sizeof (ds) - __builtin_offsetof (struct DS, d) - n + 2)
+    FAIL ();
   if (test_substring_ptrplus (128, 4) != (128 - 4) * sizeof (int))
     FAIL ();
   if (test_substring_ptrplus (128, 142) != 0)
diff --git a/gcc/testsuite/gcc.dg/c2x-auto-1.c b/gcc/testsuite/gcc.dg/c2x-auto-1.c
index f8460fb..c50dacc 100644
--- a/gcc/testsuite/gcc.dg/c2x-auto-1.c
+++ b/gcc/testsuite/gcc.dg/c2x-auto-1.c
@@ -4,14 +4,14 @@
 
 auto i = 1;
 extern int i;
-static auto l = { 0L };
+static auto l = 0L;
 extern long l;
 extern auto const d = 0.0; /* { dg-warning "initialized and declared 'extern'" } */
 extern const double d;
 double dx;
 auto ((i2)) = 3;
 extern int i2;
-const auto i3 [[]] = { 4, };
+const auto i3 [[]] = 4;
 extern int i4;
 thread_local auto f = 1.0f;
 float ff;
diff --git a/gcc/testsuite/gcc.dg/c2x-auto-3.c b/gcc/testsuite/gcc.dg/c2x-auto-3.c
index a34ce31..1ab3cc7 100644
--- a/gcc/testsuite/gcc.dg/c2x-auto-3.c
+++ b/gcc/testsuite/gcc.dg/c2x-auto-3.c
@@ -62,3 +62,10 @@ f5 ()
 {
   static int auto e10 = 3; /* { dg-error "multiple storage classes in declaration specifiers" } */
 }
+
+void
+f6 ()
+{
+  static auto l = { 0L }; /* { dg-error "expected expression" } */
+  const auto i3 [[]] = { 4, }; /* { dg-error "expected expression" } */
+}
diff --git a/gcc/testsuite/gcc.dg/c2x-nullptr-6.c b/gcc/testsuite/gcc.dg/c2x-nullptr-6.c
new file mode 100644
index 0000000..24e14fa
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/c2x-nullptr-6.c
@@ -0,0 +1,33 @@
+/* PR c/108424 */
+/* { dg-options "-std=c2x" } */
+
+struct S {
+  int i;
+  int : nullptr; /* { dg-error "not an integer constant" } */
+};
+
+enum E { X = nullptr }; /* { dg-error "not an integer constant" } */
+
+alignas(nullptr) int g; /* { dg-error "not an integer constant" } */
+
+int arr[10] = { [nullptr] = 1 }; /* { dg-error "not of integer type" } */
+
+_Static_assert (nullptr, "nullptr"); /* { dg-error "not an integer" } */
+
+void f (int n)
+{
+  switch (n) {
+  case nullptr: /* { dg-error "an integer constant" } */
+  default:
+  }
+
+  switch (n) {
+  case 1 ... nullptr: /* { dg-error "an integer constant" } */
+  default:
+  }
+
+  switch (n) {
+  case nullptr ... 2: /* { dg-error "an integer constant" } */
+  default:
+  }
+}
diff --git a/gcc/testsuite/gcc.dg/guality/pr36728-2.c b/gcc/testsuite/gcc.dg/guality/pr36728-2.c
index 6e8d775..d670c87 100644
--- a/gcc/testsuite/gcc.dg/guality/pr36728-2.c
+++ b/gcc/testsuite/gcc.dg/guality/pr36728-2.c
@@ -25,21 +25,21 @@ foo (int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7)
    and arg2.  So it is expected that these values are unavailable in
    some of these tests.  */
 
-/* { dg-final { gdb-test 16 "arg1" "1" { target { ! "s390*-*-*" } xfail { aarch64*-*-* && { any-opts "-fno-fat-lto-objects" "-O3" } } } } } */
-/* { dg-final { gdb-test 16 "arg2" "2" { target { ! "s390*-*-*" } xfail { aarch64*-*-* && { any-opts "-fno-fat-lto-objects" "-O3" } } } } } */
-/* { dg-final { gdb-test 16 "arg3" "3" { xfail { aarch64*-*-* && { any-opts "-fno-fat-lto-objects" "-O3" } } } } } */
-/* { dg-final { gdb-test 16 "arg4" "4" { xfail { aarch64*-*-* && { any-opts "-fno-fat-lto-objects" "-O3" } } } } } */
-/* { dg-final { gdb-test 16 "arg5" "5" { xfail { aarch64*-*-* && { any-opts "-fno-fat-lto-objects" "-O3" } } } } } */
-/* { dg-final { gdb-test 16 "arg6" "6" { xfail { aarch64*-*-* && { any-opts "-fno-fat-lto-objects" "-O3" } } } } } */
-/* { dg-final { gdb-test 16 "arg7" "30" { xfail { aarch64*-*-* && { any-opts "-fno-fat-lto-objects" "-O3" } } } } } */
+/* { dg-final { gdb-test 16 "arg1" "1" { target { ! "s390*-*-*" } } } } */
+/* { dg-final { gdb-test 16 "arg2" "2" } } */
+/* { dg-final { gdb-test 16 "arg3" "3" } } */
+/* { dg-final { gdb-test 16 "arg4" "4" } } */
+/* { dg-final { gdb-test 16 "arg5" "5" } } */
+/* { dg-final { gdb-test 16 "arg6" "6" } } */
+/* { dg-final { gdb-test 16 "arg7" "30" } } */
 /* { dg-final { gdb-test 16 "y" "2" { xfail { aarch64*-*-* && { any-opts "-fno-fat-lto-objects" } } } } } */
-/* { dg-final { gdb-test 18 "arg1" "1" { target { ! "s390*-*-*" } xfail { aarch64*-*-* && { any-opts "-fno-fat-lto-objects" "-O3" } } } } } */
-/* { dg-final { gdb-test 18 "arg2" "2" { target { ! "s390*-*-*" } xfail { aarch64*-*-* && { any-opts "-fno-fat-lto-objects" "-O3" } } } } } */
-/* { dg-final { gdb-test 18 "arg3" "3" { xfail { aarch64*-*-* && { any-opts "-fno-fat-lto-objects" "-O3" } } } } } */
-/* { dg-final { gdb-test 18 "arg4" "4" { xfail { aarch64*-*-* && { any-opts "-fno-fat-lto-objects" "-O3" } } } } } */
-/* { dg-final { gdb-test 18 "arg5" "5" { xfail { aarch64*-*-* && { any-opts "-fno-fat-lto-objects" "-O3" } } } } } */
-/* { dg-final { gdb-test 18 "arg6" "6" { xfail { aarch64*-*-* && { any-opts "-fno-fat-lto-objects" "-O3" } } } } } */
-/* { dg-final { gdb-test 18 "arg7" "30" { xfail { aarch64*-*-* && { any-opts "-fno-fat-lto-objects" "-O3" } } } } } */
+/* { dg-final { gdb-test 18 "arg1" "1" { target { ! "s390*-*-*" } } } } */
+/* { dg-final { gdb-test 18 "arg2" "2" { target { ! "s390*-*-*" } } } } */
+/* { dg-final { gdb-test 18 "arg3" "3" } } */
+/* { dg-final { gdb-test 18 "arg4" "4" } } */
+/* { dg-final { gdb-test 18 "arg5" "5" } } */
+/* { dg-final { gdb-test 18 "arg6" "6" } } */
+/* { dg-final { gdb-test 18 "arg7" "30" } } */
 /* { dg-final { gdb-test 18 "*x" "(char) 25" } } */
 /* { dg-final { gdb-test 18 "y" "2" } } */
 
diff --git a/gcc/testsuite/gcc.dg/guality/pr54519-1.c b/gcc/testsuite/gcc.dg/guality/pr54519-1.c
index 5880d9b..81703eb 100644
--- a/gcc/testsuite/gcc.dg/guality/pr54519-1.c
+++ b/gcc/testsuite/gcc.dg/guality/pr54519-1.c
@@ -18,9 +18,9 @@ fn2 (int x, int y, int z)
       fn1 (x);		/* { dg-final { gdb-test .+2 "x" "36" } } */
       if (x == 36)	/* { dg-final { gdb-test .+1 "y" "25" { xfail { aarch64*-*-* && { any-opts "-flto" } } } } } */
 	fn1 (x);	/* { dg-final { gdb-test . "z" "6" { xfail { aarch64*-*-* && { any-opts "-flto" } } } } } */
-      fn1 (x);		/* { dg-final { gdb-test .+2 "x" "98" { xfail { aarch64*-*-* && { any-opts "-Os" } } } } } */
-      if (x == 98)	/* { dg-final { gdb-test .+1 "y" "117" { xfail { aarch64*-*-* && { any-opts "-Os" "-flto" } } } } } */
-	fn1 (x);	/* { dg-final { gdb-test . "z" "8" { xfail { aarch64*-*-* && { any-opts "-Os" "-flto" } } } } } */
+      fn1 (x);		/* { dg-final { gdb-test .+2 "x" "98" } } */
+      if (x == 98)	/* { dg-final { gdb-test .+1 "y" "117" { xfail { aarch64*-*-* && { any-opts "-flto" } } } } } */
+	fn1 (x);	/* { dg-final { gdb-test . "z" "8" { xfail { aarch64*-*-* && { any-opts "-flto" } } } } } */
       fn1 (x);
       fn1 (x + a);
     }
diff --git a/gcc/testsuite/gcc.dg/guality/pr54519-3.c b/gcc/testsuite/gcc.dg/guality/pr54519-3.c
index 9c18993..fabab96 100644
--- a/gcc/testsuite/gcc.dg/guality/pr54519-3.c
+++ b/gcc/testsuite/gcc.dg/guality/pr54519-3.c
@@ -18,9 +18,9 @@ fn2 (int x, int y, int z)
       fn1 (x);		/* { dg-final { gdb-test .+2 "x" "36" } } */
       if (x == 36)	/* { dg-final { gdb-test .+1 "y" "25" { xfail { aarch64*-*-* && { any-opts "-flto" } } } } } */
 	fn1 (x);	/* { dg-final { gdb-test . "z" "6" { xfail { aarch64*-*-* && { any-opts "-flto" } } } } } */
-      fn1 (x);		/* { dg-final { gdb-test .+2 "x" "98" { xfail { aarch64*-*-* && { any-opts "-Os" } } } } } */
-      if (x == 98)	/* { dg-final { gdb-test .+1 "y" "117" { xfail { aarch64*-*-* && { any-opts "-Os" "-flto" } } } } } */
-	fn1 (x);	/* { dg-final { gdb-test . "z" "8" { xfail { aarch64*-*-* && { any-opts "-Os" "-flto" } } } } } */
+      fn1 (x);		/* { dg-final { gdb-test .+2 "x" "98" } } */
+      if (x == 98)	/* { dg-final { gdb-test .+1 "y" "117" { xfail { aarch64*-*-* && { any-opts "-flto" } } } } } */
+	fn1 (x);	/* { dg-final { gdb-test . "z" "8" { xfail { aarch64*-*-* && { any-opts "-flto" } } } } } */
       fn1 (x);
       fn1 (x + a);
     }
diff --git a/gcc/testsuite/gcc.dg/guality/pr54693-2.c b/gcc/testsuite/gcc.dg/guality/pr54693-2.c
index 68aa6c6..7a0ae73 100644
--- a/gcc/testsuite/gcc.dg/guality/pr54693-2.c
+++ b/gcc/testsuite/gcc.dg/guality/pr54693-2.c
@@ -17,8 +17,8 @@ foo (int x, int y, int z)
   int i = 0;
   while (x > 3 && y > 3 && z > 3)
     {		/* { dg-final { gdb-test .+2 "i" "v + 1" } } */
-		/* { dg-final { gdb-test .+1 "x" "10 - i" } } */
-      bar (i);	/* { dg-final { gdb-test . "y" "20 - 2 * i" } } */
+		/* { dg-final { gdb-test .+1 "x" "10 - i" { xfail { aarch64*-*-* && { any-opts "-fno-fat-lto-objects" } } } } } */
+      bar (i);	/* { dg-final { gdb-test . "y" "20 - 2 * i" { xfail { aarch64*-*-* && { any-opts "-fno-fat-lto-objects" } } } } } */
 		/* { dg-final { gdb-test .-1 "z" "30 - 3 * i" { xfail { aarch64*-*-* && { any-opts "-fno-fat-lto-objects" "-Os" } } } } } */
       i++, x--, y -= 2, z -= 3;
     }
diff --git a/gcc/testsuite/gcc.dg/guality/sra-1.c b/gcc/testsuite/gcc.dg/guality/sra-1.c
index e9b920e..c0d1cf6 100644
--- a/gcc/testsuite/gcc.dg/guality/sra-1.c
+++ b/gcc/testsuite/gcc.dg/guality/sra-1.c
@@ -39,7 +39,7 @@ f3 (int k)
   struct B a = { 4, k + 6 };
   asm ("" : "+r" (a.i));
   a.j++;
-  bar (a.i);		/* { dg-final { gdb-test .+1 "a.i" "4" { xfail { aarch64*-*-* && { any-opts "-Og" } } } } } */
+  bar (a.i);		/* { dg-final { gdb-test .+1 "a.i" "4" { xfail { aarch64*-*-* && { { any-opts "-Og" "-O2" "-O3" } && { ! { any-opts "-fno-fat-lto-objects" } } } } } } } */
   bar (a.j);		/* { dg-final { gdb-test . "a.j" "14" { xfail { aarch64*-*-* && { any-opts "-Og" "-fno-fat-lto-objects" } } } } } */
   return a.i + a.j;
 }
diff --git a/gcc/testsuite/gcc.dg/ipa/ipa-sra-30.c b/gcc/testsuite/gcc.dg/ipa/ipa-sra-30.c
new file mode 100644
index 0000000..5c8e8ed
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/ipa/ipa-sra-30.c
@@ -0,0 +1,31 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-ipa-sra"  } */
+struct list
+{
+	 struct list *next;
+	 int val;
+};
+__attribute__ ((noinline))
+static int reta (int *a)
+{
+	return *a;
+}
+__attribute__ ((noinline))
+static int
+kill(struct list *l, int *a)
+{
+	int v;
+	while (l)
+	{
+		v = l->val;
+		l=l->next;
+	}
+	return reta (a) + v;
+}
+int
+test(struct list *l, int *a)
+{
+	return kill (l, a);
+}
+/* Loop in kill may be infinite; do not SRA.  */
+/* { dg-final { scan-ipa-dump-not "Created new node kill.isra"  "sra"  } } */
diff --git a/gcc/testsuite/gcc.dg/ipa/ipa-sra-31.c b/gcc/testsuite/gcc.dg/ipa/ipa-sra-31.c
new file mode 100644
index 0000000..0a636d6
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/ipa/ipa-sra-31.c
@@ -0,0 +1,4 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-ipa-sra -ffinite-loops"  } */
+#include "ipa-sra-30.c"
+/* { dg-final { scan-ipa-dump "Created new node kill.isra"  "sra"  } } */
diff --git a/gcc/testsuite/gcc.dg/lto/pr108445_0.c b/gcc/testsuite/gcc.dg/lto/pr108445_0.c
new file mode 100644
index 0000000..06dac69
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/lto/pr108445_0.c
@@ -0,0 +1,4 @@
+/* { dg-lto-do link } */
+/* { dg-lto-options { "-g -O2 -flto" } } */
+
+int gArray[16];
diff --git a/gcc/testsuite/gcc.dg/lto/pr108445_1.c b/gcc/testsuite/gcc.dg/lto/pr108445_1.c
new file mode 100644
index 0000000..50db9fe
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/lto/pr108445_1.c
@@ -0,0 +1,19 @@
+extern int gArray[];
+
+int foo(int *a)
+{
+  int *p = a;
+
+  return *p;
+}
+
+int main(int argc, char *argv[])
+{
+  if (argc & 1)
+    gArray[argc - 1] = 1;
+
+  if (argc > 1)
+    return foo(gArray);
+
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/pr106061.c b/gcc/testsuite/gcc.dg/pr106061.c
new file mode 100644
index 0000000..bba8d29
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr106061.c
@@ -0,0 +1,18 @@
+/* PR ipa/106061 */
+/* { dg-do compile } */
+/* { dg-options "-Og" } */
+
+extern void foo (void);
+
+inline void
+bar (int x)
+{
+  if (x)
+    foo ();
+}
+
+void
+baz (void)
+{
+  bar (0);
+}
diff --git a/gcc/testsuite/gcc.dg/pr108306.c b/gcc/testsuite/gcc.dg/pr108306.c
new file mode 100644
index 0000000..1044c64
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr108306.c
@@ -0,0 +1,29 @@
+/* { dg-do compile } */
+/* { dg-options "-O2  -fno-strict-overflow -fsanitize=shift -Warray-bounds" } */
+
+enum psi_task_count {
+	NR_IOWAIT,
+	NR_PSI_TASK_COUNTS = 4,
+};
+
+unsigned int tasks[NR_PSI_TASK_COUNTS];
+
+static void psi_group_change(unsigned int set)
+{
+	unsigned int t;
+	unsigned int state_mask = 0;
+
+	for (t = 0; set; set &= ~(1 << t), t++)
+		if (set & (1 << t))
+			tasks[t]++;
+}
+
+void psi_task_switch(int sleep)
+{
+	int set = 0;
+
+	if (sleep)
+		set |= (1 << NR_IOWAIT);
+
+	psi_group_change(set);
+}
diff --git a/gcc/testsuite/gcc.dg/pr108447.c b/gcc/testsuite/gcc.dg/pr108447.c
new file mode 100644
index 0000000..cfbaba6
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr108447.c
@@ -0,0 +1,33 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+__attribute__((noipa)) int
+foo (float x, float y)
+{
+  _Bool cmp1 = x <= y;
+  _Bool cmp2 = x >= y;
+  if (cmp1 && cmp2)
+    return 1;
+  else if (!cmp1 && !cmp2)
+    return -1;
+  return 0;
+}
+
+int
+main ()
+{
+  if (foo (0.0f, __builtin_nanf ("")) != -1)
+    __builtin_abort ();
+  if (foo (__builtin_nanf (""), -42.0f) != -1)
+    __builtin_abort ();
+  if (foo (0.0f, -0.0f) != 1)
+    __builtin_abort ();
+  if (foo (42.0f, 42.0f) != 1)
+    __builtin_abort ();
+  if (foo (42.0f, -0.0f) != 0)
+    __builtin_abort ();
+  if (foo (0.0f, -42.0f) != 0)
+    __builtin_abort ();
+  return 0;
+}
+
diff --git a/gcc/testsuite/gcc.dg/pr108449.c b/gcc/testsuite/gcc.dg/pr108449.c
new file mode 100644
index 0000000..4a3ae5b
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr108449.c
@@ -0,0 +1,5 @@
+/* { dg-do compile } */
+/* { dg-options "-O" } */
+
+static int vfork(); /* { dg-warning "used but never defined" } */
+void f() { vfork(); }
diff --git a/gcc/testsuite/gcc.dg/pr108582-1.c b/gcc/testsuite/gcc.dg/pr108582-1.c
new file mode 100644
index 0000000..88c2de36
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr108582-1.c
@@ -0,0 +1,58 @@
+/* { dg-do compile } */
+/* { dg-options "-O3 -fno-tree-ccp -fno-tree-dce" } */
+
+/*
+  PHI-OPT via match_simplify_replacement used to transform:
+  if (_25 != 0)
+    goto <bb 8>; [25.00%]
+  else
+    goto <bb 9>; [75.00%]
+
+  <bb 8> [local count: 11649864]:
+  # iftmp.5_13 = PHI <2(7)>
+  k_22 = k_11 | iftmp.5_13;
+
+  <bb 9> [local count: 105655256]:
+  # g_9 = PHI <1(2), 0(8), g_8(7)>
+  # k_12 = PHI <k_20(D)(2), k_22(8), k_11(7)>
+
+into:
+
+  _15 = (int) _25;
+  _28 = -_15;
+  _4 = _13 & _28;
+  _6 = _4 | k_11;
+
+  <bb 8> [local count: 105655256]:
+  # g_9 = PHI <1(2), g_8(7)>
+  # k_12 = PHI <k_20(D)(2), _6(7)>
+
+Removing the phi-node/assignment of _13.
+
+ */
+
+int a, c, d, e, f;
+char b;
+int main() {
+  int g = 1;
+  char h[1] = {0};
+  while (a) {
+    if (f) {
+      b = 0;
+      if (d)
+        continue;
+    }
+    if (a < 1) {
+      g = 0;
+      goto L;
+    }
+  }
+  while (c) {
+    char *j = h;
+    int k;
+  L:
+    if (e && !g)
+      k |= 2 | (*j < 0);
+  }
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/pr95115.c b/gcc/testsuite/gcc.dg/pr95115.c
index 69c4f83..e7c3119 100644
--- a/gcc/testsuite/gcc.dg/pr95115.c
+++ b/gcc/testsuite/gcc.dg/pr95115.c
@@ -6,7 +6,7 @@
 #include <fenv.h>
 #include <stdlib.h>
 
-double
+__attribute__ ((noipa)) double
 x (void)
 {
   double d = __builtin_inf ();
diff --git a/gcc/testsuite/gcc.dg/torture/pr108482.c b/gcc/testsuite/gcc.dg/torture/pr108482.c
new file mode 100644
index 0000000..8dc1169
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/pr108482.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+
+int g_30, g_261, g_263, func_1___trans_tmp_17;
+int **g_120;
+int *g_530;
+void func_1() {
+  int *l_29 = &g_30;
+  *l_29 = 1;
+  g_263 = 0;
+  for (; g_263 <= 1; g_263 += 1) {
+    g_530 = 0;
+    if (*l_29) {
+      char *l_1694 = (char *)&g_261;
+      *l_1694 &= **g_120;
+    } else
+      *l_29 ^= func_1___trans_tmp_17;
+  }
+}
diff --git a/gcc/testsuite/gcc.dg/torture/pr108523.c b/gcc/testsuite/gcc.dg/torture/pr108523.c
new file mode 100644
index 0000000..a04160b
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/pr108523.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+
+int g_149, g_167, g_481;
+int main() {
+  int *l_1478 = &g_149;
+  *l_1478 ^= g_167;
+lbl_1481:
+  for (;;) {
+    g_481 = 1;
+    for (; g_481 < 100000; g_481 += 1) {
+      g_167 ^= *l_1478;
+      if (g_149)
+        goto lbl_1481;
+    }
+  }
+}
diff --git a/gcc/testsuite/gcc.dg/torture/pr108574-1.c b/gcc/testsuite/gcc.dg/torture/pr108574-1.c
new file mode 100644
index 0000000..7066b5e
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/pr108574-1.c
@@ -0,0 +1,19 @@
+/* { dg-do run } */
+
+int a = 1, b, c = 2, d;
+int main() {
+  if (b)
+    goto L2;
+ L1:
+  {
+    int e = c;
+    a = 1 % a;
+    while (e && 1 <= d)
+      ;
+    d >= b;
+  L2:
+    if (1 >= e)
+      goto L1;
+  }
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/torture/pr108574-2.c b/gcc/testsuite/gcc.dg/torture/pr108574-2.c
new file mode 100644
index 0000000..1e38d08
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/pr108574-2.c
@@ -0,0 +1,25 @@
+/* { dg-do run } */
+
+int a, b, c, d, e, f, g = -1, h;
+void l() {
+  if (!e)
+    goto i;
+  for (; g; g++) {
+    b = ~d;
+    int j = 0, k = 1;
+    if (k && (b || f))
+      j = b;
+  i:
+    a = ~j;
+  }
+}
+int main() {
+  h = 3;
+  for (; h; h--) {
+    e = 1;
+    int m = ~a, n = 1 % m;
+    c = n;
+    l();
+  }
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/torture/pr108574-3.c b/gcc/testsuite/gcc.dg/torture/pr108574-3.c
new file mode 100644
index 0000000..b4d5dae
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/pr108574-3.c
@@ -0,0 +1,27 @@
+/* { dg-do run } */
+
+int a = 3557301289, d;
+signed char b, f;
+unsigned short c = 241;
+short e, g;
+static void h() {
+  if (!a)
+    goto i;
+  b = a;
+  for (; a < 2; a = b) {
+    unsigned short j;
+    if (c || !g) {
+      j = c;
+    i:
+      e = j;
+    }
+    f = j;
+    d = ~(f & ~2880764155);
+    while (d > -2316069)
+      ;
+  }
+}
+int main() {
+  h();
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/modref-dse-7.c b/gcc/testsuite/gcc.dg/tree-ssa/modref-dse-7.c
new file mode 100644
index 0000000..85a01d3
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/modref-dse-7.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized"  } */
+struct list
+{
+	 struct list *next;
+};
+__attribute__ ((noinline))
+void
+kill(struct list *l, int *a)
+{
+	while (l)
+		l=l->next;
+	*a = 0;
+}
+void
+test(struct list *l, int *a)
+{
+	*a=12345;
+	kill (l, a);
+	return;
+}
+/* { dg-final { scan-tree-dump-not "12345" "optimized"} } */
diff --git a/gcc/testsuite/gcc.dg/uninit-pr108547.c b/gcc/testsuite/gcc.dg/uninit-pr108547.c
new file mode 100644
index 0000000..d8f6c9f
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/uninit-pr108547.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wuninitialized" } */
+
+int func_7_uc_10li_19 (int);
+int li_4, li_5, us_8;
+unsigned char func_7_ptr_13, func_7_uc_14;
+void func_7_ptr_18() {
+  if (li_5) {
+    for (;;)
+      ;
+    short s_15;
+    for (; func_7_uc_14;) {
+      us_8 = 7;
+      for (; us_8; us_8 += 1)
+      lblD2AF1FAB:
+        if (us_8)
+          li_4 = 1;
+      func_7_uc_14 += (__INTPTR_TYPE__)func_7_ptr_18;
+      if (func_7_ptr_13 & 1 && (func_7_uc_14 &= func_7_ptr_13))
+        s_15 %= func_7_uc_10li_19(s_15); /* { dg-warning "uninitialized" } */
+    }
+  }
+  goto lblD2AF1FAB;
+}
diff --git a/gcc/testsuite/gcc.dg/vect/complex/fast-math-bb-slp-complex-add-pattern-half-float.c b/gcc/testsuite/gcc.dg/vect/complex/fast-math-bb-slp-complex-add-pattern-half-float.c
index 885fd97..e30df0f 100644
--- a/gcc/testsuite/gcc.dg/vect/complex/fast-math-bb-slp-complex-add-pattern-half-float.c
+++ b/gcc/testsuite/gcc.dg/vect/complex/fast-math-bb-slp-complex-add-pattern-half-float.c
@@ -12,5 +12,5 @@
 
 /* { dg-final { scan-tree-dump-times "stmt.*COMPLEX_ADD_ROT90" 1 "slp1" { target { vect_complex_add_half } } } } */
 /* { dg-final { scan-tree-dump-times "stmt.*COMPLEX_ADD_ROT270" 1 "slp1" { target { vect_complex_add_half } && ! target { arm*-*-* } } } } */
-/* { dg-final { scan-tree-dump "Found COMPLEX_ADD_ROT270" "slp1" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump "Found COMPLEX_ADD_ROT270" "slp1" } } */
 /* { dg-final { scan-tree-dump "Found COMPLEX_ADD_ROT90" "slp1" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-add-half-float.c b/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-add-half-float.c
index c656a2f..046f014 100644
--- a/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-add-half-float.c
+++ b/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-add-half-float.c
@@ -9,5 +9,5 @@
 
 /* Vectorization is failing for these cases.  They should work but for now ignore.  */
 
-/* { dg-final { scan-tree-dump-times "stmt.*COMPLEX_ADD_ROT270" 1 "slp1" { xfail *-*-* } } } */
-/* { dg-final { scan-tree-dump-times "stmt.*COMPLEX_ADD_ROT90" 1 "slp1" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "stmt.*COMPLEX_ADD_ROT270" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "stmt.*COMPLEX_ADD_ROT90" 1 "vect" { xfail *-*-* } } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-bitfield-write-2.c b/gcc/testsuite/gcc.dg/vect/vect-bitfield-write-2.c
index d550dd3..1a10135 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-bitfield-write-2.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-bitfield-write-2.c
@@ -1,4 +1,5 @@
 /* { dg-require-effective-target vect_int } */
+/* { dg-require-effective-target vect_long_long } */
 
 #include <stdarg.h>
 #include "tree-vect.h"
diff --git a/gcc/testsuite/gcc.dg/vect/vect-bitfield-write-3.c b/gcc/testsuite/gcc.dg/vect/vect-bitfield-write-3.c
index 3303d26..5dc6796 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-bitfield-write-3.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-bitfield-write-3.c
@@ -1,4 +1,5 @@
 /* { dg-require-effective-target vect_int } */
+/* { dg-require-effective-target vect_long_long } */
 
 #include <stdarg.h>
 #include "tree-vect.h"
diff --git a/gcc/testsuite/gcc.dg/vect/vect-fmax-1.c b/gcc/testsuite/gcc.dg/vect/vect-fmax-1.c
index 841ffab..d3aa5b0 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-fmax-1.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-fmax-1.c
@@ -1,3 +1,5 @@
+/* { dg-require-effective-target vect_float } */
+
 #include "tree-vect.h"
 
 #ifndef TYPE
diff --git a/gcc/testsuite/gcc.dg/vect/vect-fmax-2.c b/gcc/testsuite/gcc.dg/vect/vect-fmax-2.c
index 3d1f644..d455dd4 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-fmax-2.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-fmax-2.c
@@ -1,3 +1,5 @@
+/* { dg-require-effective-target vect_float } */
+
 #define TYPE double
 #define FN __builtin_fmax
 
diff --git a/gcc/testsuite/gcc.dg/vect/vect-fmax-3.c b/gcc/testsuite/gcc.dg/vect/vect-fmax-3.c
index f711ed0..58e74e2 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-fmax-3.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-fmax-3.c
@@ -1,3 +1,5 @@
+/* { dg-require-effective-target vect_float } */
+
 #include "tree-vect.h"
 
 void __attribute__((noipa))
diff --git a/gcc/testsuite/gcc.dg/vect/vect-fmin-1.c b/gcc/testsuite/gcc.dg/vect/vect-fmin-1.c
index 3d5f843..281fdf2 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-fmin-1.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-fmin-1.c
@@ -1,3 +1,5 @@
+/* { dg-require-effective-target vect_float } */
+
 #include "tree-vect.h"
 
 #ifndef TYPE
diff --git a/gcc/testsuite/gcc.dg/vect/vect-fmin-2.c b/gcc/testsuite/gcc.dg/vect/vect-fmin-2.c
index 21e45cc..ee9e134 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-fmin-2.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-fmin-2.c
@@ -1,3 +1,5 @@
+/* { dg-require-effective-target vect_float } */
+
 #ifndef TYPE
 #define TYPE double
 #define FN __builtin_fmin
diff --git a/gcc/testsuite/gcc.dg/vect/vect-fmin-3.c b/gcc/testsuite/gcc.dg/vect/vect-fmin-3.c
index cc38bf4..2e282ba 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-fmin-3.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-fmin-3.c
@@ -1,3 +1,5 @@
+/* { dg-require-effective-target vect_float } */
+
 #include "tree-vect.h"
 
 void __attribute__((noipa))
diff --git a/gcc/testsuite/gcc.target/aarch64/acle/pmull64.c b/gcc/testsuite/gcc.target/aarch64/acle/pmull64.c
new file mode 100644
index 0000000..6a1e99e
--- /dev/null
+++ b/gcc/testsuite/gcc.target/aarch64/acle/pmull64.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-additional-options "-march=armv8.2-a" } */
+
+#pragma push_options
+#pragma GCC target ("+aes")
+
+#include "arm_neon.h"
+
+int foo (poly64_t a, poly64_t b)
+{
+  return vgetq_lane_s32 (vreinterpretq_s32_p128 (vmull_p64 (a, b)), 0);
+}
+
+/* { dg-final { scan-assembler "\tpmull\tv" } } */
diff --git a/gcc/testsuite/gcc.target/aarch64/aes-fuse-1.c b/gcc/testsuite/gcc.target/aarch64/aes-fuse-1.c
index d7b4f89..1b4e10f 100644
--- a/gcc/testsuite/gcc.target/aarch64/aes-fuse-1.c
+++ b/gcc/testsuite/gcc.target/aarch64/aes-fuse-1.c
@@ -1,6 +1,6 @@
 /* { dg-do compile } */
-/* { dg-options "-O3 -mcpu=cortex-a72+crypto -dp" } */
-/* { dg-additional-options "-march=armv8-a+crypto" { target { aarch64*-*-* } } }*/
+/* { dg-options "-O3 -mcpu=cortex-a72+aes -dp" } */
+/* { dg-additional-options "-march=armv8-a+aes" { target { aarch64*-*-* } } }*/
 
 #include <arm_neon.h>
 
diff --git a/gcc/testsuite/gcc.target/aarch64/aes-fuse-2.c b/gcc/testsuite/gcc.target/aarch64/aes-fuse-2.c
index dfe01b0..4c028b3 100644
--- a/gcc/testsuite/gcc.target/aarch64/aes-fuse-2.c
+++ b/gcc/testsuite/gcc.target/aarch64/aes-fuse-2.c
@@ -1,6 +1,6 @@
 /* { dg-do compile } */
-/* { dg-options "-O3 -mcpu=cortex-a72+crypto -dp" } */
-/* { dg-additional-options "-march=armv8-a+crypto" { target { aarch64*-*-* } } }*/
+/* { dg-options "-O3 -mcpu=cortex-a72+aes -dp" } */
+/* { dg-additional-options "-march=armv8-a+aes" { target { aarch64*-*-* } } }*/
 
 #include <arm_neon.h>
 
diff --git a/gcc/testsuite/gcc.target/aarch64/aes_1.c b/gcc/testsuite/gcc.target/aarch64/aes_1.c
index 5578e85..754c4ab 100644
--- a/gcc/testsuite/gcc.target/aarch64/aes_1.c
+++ b/gcc/testsuite/gcc.target/aarch64/aes_1.c
@@ -1,6 +1,6 @@
 
 /* { dg-do compile } */
-/* { dg-options "-march=armv8-a+crypto" } */
+/* { dg-options "-march=armv8-a+aes" } */
 
 #include "arm_neon.h"
 
diff --git a/gcc/testsuite/gcc.target/aarch64/aes_2.c b/gcc/testsuite/gcc.target/aarch64/aes_2.c
index 70f113f..442c100 100644
--- a/gcc/testsuite/gcc.target/aarch64/aes_2.c
+++ b/gcc/testsuite/gcc.target/aarch64/aes_2.c
@@ -1,6 +1,6 @@
 
 /* { dg-do compile } */
-/* { dg-options "-O3 -march=armv8-a+crypto" } */
+/* { dg-options "-O3 -march=armv8-a+aes" } */
 
 #include "arm_neon.h"
 
@@ -76,4 +76,6 @@ test7 (uint8x16_t a, uint8x16_t b)
   return result;
 }
 /* { dg-final { scan-assembler-not "mov" } } */
+/* { dg-final { scan-assembler "aesd\tv" } } */
+/* { dg-final { scan-assembler "aese\tv" } } */
 
diff --git a/gcc/testsuite/gcc.target/aarch64/aes_xor_combine.c b/gcc/testsuite/gcc.target/aarch64/aes_xor_combine.c
index 833e9b3..ee0f0e9 100644
--- a/gcc/testsuite/gcc.target/aarch64/aes_xor_combine.c
+++ b/gcc/testsuite/gcc.target/aarch64/aes_xor_combine.c
@@ -1,5 +1,5 @@
 /* { dg-do compile } */
-/* { dg-options "-O3 -mcpu=cortex-a55+crypto" } */
+/* { dg-options "-O3 -mcpu=cortex-a55+aes" } */
 #include <arm_neon.h>
 
 #define AESE(r, v, key) (r = vaeseq_u8 ((v), (key)));
diff --git a/gcc/testsuite/gcc.target/aarch64/bfloat16_scalar_typecheck.c b/gcc/testsuite/gcc.target/aarch64/bfloat16_scalar_typecheck.c
index 7c9188c..f4ae680 100644
--- a/gcc/testsuite/gcc.target/aarch64/bfloat16_scalar_typecheck.c
+++ b/gcc/testsuite/gcc.target/aarch64/bfloat16_scalar_typecheck.c
@@ -40,7 +40,7 @@ bfloat16_t footest (bfloat16_t scalar0)
   short initi_1_4 = glob_bfloat; /* { dg-error {invalid conversion from type 'bfloat16_t'} } */
   double initi_1_5 = glob_bfloat; /* { dg-error {invalid conversion from type 'bfloat16_t'} } */
 
-  bfloat16_t scalar2_1 = {}; /* { dg-error {empty scalar initializer} } */
+  bfloat16_t scalar2_1 = {};
   bfloat16_t scalar2_2 = { glob_bfloat };
   bfloat16_t scalar2_3 = { 0 }; /* { dg-error {invalid conversion to type 'bfloat16_t'} } */
   bfloat16_t scalar2_4 = { 0.1 }; /* { dg-error {invalid conversion to type 'bfloat16_t'} } */
@@ -92,7 +92,7 @@ bfloat16_t footest (bfloat16_t scalar0)
 
   /* Compound literals.  */
 
-  (bfloat16_t) {}; /* { dg-error {empty scalar initializer} } */
+  (bfloat16_t) {};
   (bfloat16_t) { glob_bfloat };
   (bfloat16_t) { 0 }; /* { dg-error {invalid conversion to type 'bfloat16_t'} } */
   (bfloat16_t) { 0.1 }; /* { dg-error {invalid conversion to type 'bfloat16_t'} } */
diff --git a/gcc/testsuite/gcc.target/aarch64/bitfield-abi-warning-align16-O2-extra.c b/gcc/testsuite/gcc.target/aarch64/bitfield-abi-warning-align16-O2-extra.c
index f248a12..3b2c932 100644
--- a/gcc/testsuite/gcc.target/aarch64/bitfield-abi-warning-align16-O2-extra.c
+++ b/gcc/testsuite/gcc.target/aarch64/bitfield-abi-warning-align16-O2-extra.c
@@ -1,5 +1,5 @@
 /* { dg-do compile } */
-/* { dg-options "-O2 -save-temps" } */
+/* { dg-options "-O2 -fno-stack-protector -save-temps" } */
 
 #define ALIGN 16
 //#define EXTRA
diff --git a/gcc/testsuite/gcc.target/aarch64/bitfield-abi-warning-align16-O2.c b/gcc/testsuite/gcc.target/aarch64/bitfield-abi-warning-align16-O2.c
index 22ee5ec..ee5d6fa 100644
--- a/gcc/testsuite/gcc.target/aarch64/bitfield-abi-warning-align16-O2.c
+++ b/gcc/testsuite/gcc.target/aarch64/bitfield-abi-warning-align16-O2.c
@@ -1,5 +1,5 @@
 /* { dg-do compile } */
-/* { dg-options "-O2 -save-temps" } */
+/* { dg-options "-O2 -fno-stack-protector -save-temps" } */
 
 #define ALIGN 16
 #define EXTRA
diff --git a/gcc/testsuite/gcc.target/aarch64/bitfield-abi-warning-align32-O2-extra.c b/gcc/testsuite/gcc.target/aarch64/bitfield-abi-warning-align32-O2-extra.c
index a8a50b3..6d4a883 100644
--- a/gcc/testsuite/gcc.target/aarch64/bitfield-abi-warning-align32-O2-extra.c
+++ b/gcc/testsuite/gcc.target/aarch64/bitfield-abi-warning-align32-O2-extra.c
@@ -1,5 +1,5 @@
 /* { dg-do compile } */
-/* { dg-options "-O2 -save-temps" } */
+/* { dg-options "-O2 -fno-stack-protector -save-temps" } */
 
 #define ALIGN 32
 //#define EXTRA
diff --git a/gcc/testsuite/gcc.target/aarch64/bitfield-abi-warning-align32-O2.c b/gcc/testsuite/gcc.target/aarch64/bitfield-abi-warning-align32-O2.c
index e872de3..331daba 100644
--- a/gcc/testsuite/gcc.target/aarch64/bitfield-abi-warning-align32-O2.c
+++ b/gcc/testsuite/gcc.target/aarch64/bitfield-abi-warning-align32-O2.c
@@ -1,5 +1,5 @@
 /* { dg-do compile } */
-/* { dg-options "-O2 -save-temps" } */
+/* { dg-options "-O2 -fno-stack-protector -save-temps" } */
 
 #define ALIGN 32
 #define EXTRA
diff --git a/gcc/testsuite/gcc.target/aarch64/bitfield-abi-warning-align8-O2.c b/gcc/testsuite/gcc.target/aarch64/bitfield-abi-warning-align8-O2.c
index cb2a945..e6d45f5 100644
--- a/gcc/testsuite/gcc.target/aarch64/bitfield-abi-warning-align8-O2.c
+++ b/gcc/testsuite/gcc.target/aarch64/bitfield-abi-warning-align8-O2.c
@@ -1,5 +1,5 @@
 /* { dg-do compile } */
-/* { dg-options "-O2 -save-temps" } */
+/* { dg-options "-O2 -fno-stack-protector -save-temps" } */
 
 #define ALIGN 8
 #define EXTRA
diff --git a/gcc/testsuite/gcc.target/aarch64/sha1_1.c b/gcc/testsuite/gcc.target/aarch64/sha1_1.c
index e208fe7..ba56c04 100644
--- a/gcc/testsuite/gcc.target/aarch64/sha1_1.c
+++ b/gcc/testsuite/gcc.target/aarch64/sha1_1.c
@@ -1,6 +1,6 @@
 
 /* { dg-do compile } */
-/* { dg-options "-march=armv8-a+crypto" } */
+/* { dg-options "-march=armv8-a+sha2" } */
 
 #include "arm_neon.h"
 
diff --git a/gcc/testsuite/gcc.target/aarch64/sha256_1.c b/gcc/testsuite/gcc.target/aarch64/sha256_1.c
index 2102daf..c3860c6 100644
--- a/gcc/testsuite/gcc.target/aarch64/sha256_1.c
+++ b/gcc/testsuite/gcc.target/aarch64/sha256_1.c
@@ -1,6 +1,6 @@
 
 /* { dg-do compile } */
-/* { dg-options "-march=armv8-a+crypto" } */
+/* { dg-options "-march=armv8-a+sha2" } */
 
 #include "arm_neon.h"
 
diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vfma_f64.c b/gcc/testsuite/gcc.target/aarch64/simd/vfma_f64.c
index ef414f1..467c740 100644
--- a/gcc/testsuite/gcc.target/aarch64/simd/vfma_f64.c
+++ b/gcc/testsuite/gcc.target/aarch64/simd/vfma_f64.c
@@ -7,33 +7,24 @@
 
 #define EPS 1.0e-15
 
-#define INHIB_OPT(x) asm volatile ("mov %d0, %1.d[0]"	\
-				   : "=w"(x)		\
-				   : "w"(x)		\
-				   : /* No clobbers. */);
-
 extern void abort (void);
 
+float64_t __attribute__((noipa))
+test_vfma (float64x1_t arg1, float64x1_t arg2, float64x1_t arg3)
+{
+  return vget_lane_f64 (vfma_f64 (arg1, arg2, arg3), 0);
+}
+
 int
 main (void)
 {
-  float64x1_t arg1;
-  float64x1_t arg2;
-  float64x1_t arg3;
-
   float64_t expected;
   float64_t actual;
 
-  arg1 = vcreate_f64 (0x3fe3955382d35b0eULL);
-  arg2 = vcreate_f64 (0x3fa88480812d6670ULL);
-  arg3 = vcreate_f64 (0x3fd5791ae2a92572ULL);
-
-  INHIB_OPT (arg1);
-  INHIB_OPT (arg2);
-  INHIB_OPT (arg3);
-
   expected = 0.6280448184360076;
-  actual = vget_lane_f64 (vfma_f64 (arg1, arg2, arg3), 0);
+  actual = test_vfma (vcreate_f64 (0x3fe3955382d35b0eULL),
+		      vcreate_f64 (0x3fa88480812d6670ULL),
+		      vcreate_f64 (0x3fd5791ae2a92572ULL));
 
   if (__builtin_fabs (expected - actual) > EPS)
     abort ();
diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vfms_f64.c b/gcc/testsuite/gcc.target/aarch64/simd/vfms_f64.c
index afbb8a8..af6ca6f 100644
--- a/gcc/testsuite/gcc.target/aarch64/simd/vfms_f64.c
+++ b/gcc/testsuite/gcc.target/aarch64/simd/vfms_f64.c
@@ -7,33 +7,24 @@
 
 #define EPS 1.0e-15
 
-#define INHIB_OPT(x) asm volatile ("mov %d0, %1.d[0]"   \
-                                   : "=w"(x)           \
-                                   : "w"(x)            \
-                                   : /* No clobbers. */);
-
 extern void abort (void);
 
+float64_t __attribute__((noipa))
+test_vfms (float64x1_t arg1, float64x1_t arg2, float64x1_t arg3)
+{
+  return vget_lane_f64 (vfms_f64 (arg1, arg2, arg3), 0);
+}
+
 int
 main (void)
 {
-  float64x1_t arg1;
-  float64x1_t arg2;
-  float64x1_t arg3;
-
   float64_t expected;
   float64_t actual;
 
-  arg1 = vcreate_f64 (0x3fe730af8db9e6f7ULL);
-  arg2 = vcreate_f64 (0x3fe6b78680fa29ceULL);
-  arg3 = vcreate_f64 (0x3feea3cbf921fbe0ULL);
-
-  INHIB_OPT (arg1);
-  INHIB_OPT (arg2);
-  INHIB_OPT (arg3);
-
   expected = 4.4964705746355915e-2;
-  actual = vget_lane_f64 (vfms_f64 (arg1, arg2, arg3), 0);
+  actual = test_vfms (vcreate_f64 (0x3fe730af8db9e6f7ULL),
+		      vcreate_f64 (0x3fe6b78680fa29ceULL),
+		      vcreate_f64 (0x3feea3cbf921fbe0ULL));
 
   if (__builtin_fabs (expected - actual) > EPS)
     abort ();
diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vmul_f64_1.c b/gcc/testsuite/gcc.target/aarch64/simd/vmul_f64_1.c
index c855c8c..dfa808c 100644
--- a/gcc/testsuite/gcc.target/aarch64/simd/vmul_f64_1.c
+++ b/gcc/testsuite/gcc.target/aarch64/simd/vmul_f64_1.c
@@ -7,19 +7,23 @@
 
 extern void abort (void);
 
+float64_t __attribute__((noipa))
+test_vmul (float64x1_t arg1, float64x1_t arg2)
+{
+  return vget_lane_f64 (vmul_f64 (arg1, arg2), 0);
+}
+
 int
 main (void)
 {
-  volatile float64_t minus_e, pi;
+  float64_t minus_e, pi;
   float64_t expected, actual;
 
   pi = 3.14159265359;
   minus_e = -2.71828;
 
   expected = pi * minus_e;
-
-  actual = vget_lane_f64 (vmul_f64 ((float64x1_t) { pi },
-                                    (float64x1_t) { minus_e }), 0);
+  actual = test_vmul ((float64x1_t) { pi }, (float64x1_t) { minus_e });
   if (expected != actual)
     abort ();
 
diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vmul_n_f64_1.c b/gcc/testsuite/gcc.target/aarch64/simd/vmul_n_f64_1.c
index f8f3cd2..91c12bc 100644
--- a/gcc/testsuite/gcc.target/aarch64/simd/vmul_n_f64_1.c
+++ b/gcc/testsuite/gcc.target/aarch64/simd/vmul_n_f64_1.c
@@ -7,19 +7,23 @@
 
 extern void abort (void);
 
+float64_t __attribute__((noipa))
+test_vmul (float64x1_t arg1, float64_t arg2)
+{
+  return vget_lane_f64 (vmul_n_f64 (arg1, arg2), 0);
+}
+
 int
 main (void)
 {
-  volatile float64_t minus_e, pi;
+  float64_t minus_e, pi;
   float64_t expected, actual;
 
   pi = 3.14159265359;
   minus_e = -2.71828;
 
   expected = pi * minus_e;
-
-  actual = vget_lane_f64 (vmul_n_f64 ((float64x1_t) { pi },
-                                       minus_e), 0);
+  actual = test_vmul ((float64x1_t) { pi }, minus_e);
   if (expected != actual)
     abort ();
 
diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vqdmlalh_laneq_s16_1.c b/gcc/testsuite/gcc.target/aarch64/simd/vqdmlalh_laneq_s16_1.c
index 9a9bd0d..aa6b89a 100644
--- a/gcc/testsuite/gcc.target/aarch64/simd/vqdmlalh_laneq_s16_1.c
+++ b/gcc/testsuite/gcc.target/aarch64/simd/vqdmlalh_laneq_s16_1.c
@@ -1,27 +1,27 @@
 /* Test the vqdmlalh_laneq_s16 AArch64 SIMD intrinsic.  */
 
 /* { dg-do run } */
-/* { dg-options "-save-temps -O3 -fno-inline" } */
+/* { dg-options "-save-temps -O3" } */
 
 #include "arm_neon.h"
 
 extern void abort (void);
 
+int32_t __attribute__((noipa))
+test_vqdmlalh (int32_t arg1, int16_t arg2, int16x8_t arg3)
+{
+  return vqdmlalh_laneq_s16 (arg1, arg2, arg3, 7);
+}
+
 int
 main (void)
 {
-  int32_t arg1;
-  int16_t arg2;
-  int16x8_t arg3;
   int32_t actual;
   int32_t expected;
 
-  arg1 = 0x80000000;
-  arg2 = -24497;
-  arg3 = vcombine_s16 (vcreate_s16 (0x008a80007fff7fffULL),
-                       vcreate_s16 (0xfffffa797fff8000ULL));
-
-  actual = vqdmlalh_laneq_s16 (arg1, arg2, arg3, 7);
+  actual = test_vqdmlalh (0x80000000, -24497,
+			  vcombine_s16 (vcreate_s16 (0x008a80007fff7fffULL),
+					vcreate_s16 (0xfffffa797fff8000ULL)));
   expected = -2147434654;
 
   if (expected != actual)
diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vqdmlals_laneq_s32_1.c b/gcc/testsuite/gcc.target/aarch64/simd/vqdmlals_laneq_s32_1.c
index 0dbe339..ea39595 100644
--- a/gcc/testsuite/gcc.target/aarch64/simd/vqdmlals_laneq_s32_1.c
+++ b/gcc/testsuite/gcc.target/aarch64/simd/vqdmlals_laneq_s32_1.c
@@ -1,27 +1,27 @@
 /* Test the vqdmlals_laneq_s32 AArch64 SIMD intrinsic.  */
 
 /* { dg-do run } */
-/* { dg-options "-save-temps -O3 -fno-inline" } */
+/* { dg-options "-save-temps -O3" } */
 
 #include "arm_neon.h"
 
 extern void abort (void);
 
+int64_t __attribute__((noipa))
+test_vqdmlals (int64_t arg1, int32_t arg2, int32x4_t arg3)
+{
+  return vqdmlals_laneq_s32 (arg1, arg2, arg3, 3);
+}
+
 int
 main (void)
 {
-  int64_t arg1;
-  int32_t arg2;
-  int32x4_t arg3;
   int64_t actual;
   int64_t expected;
 
-  arg1 = -9223182289494545592LL;
-  arg2 = 32768;
-  arg3 = vcombine_s32 (vcreate_s32 (0xffff7fff8000ffffULL),
-                       vcreate_s32 (0x80000000ffff0000ULL));
-
-  actual = vqdmlals_laneq_s32 (arg1, arg2, arg3, 3);
+  actual = test_vqdmlals (-9223182289494545592LL, 32768,
+			  vcombine_s32 (vcreate_s32 (0xffff7fff8000ffffULL),
+					vcreate_s32 (0x80000000ffff0000ULL)));
   expected = -9223323026982900920LL;
 
   if (expected != actual)
diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vqdmlslh_laneq_s16_1.c b/gcc/testsuite/gcc.target/aarch64/simd/vqdmlslh_laneq_s16_1.c
index 2763e06..0f1babc 100644
--- a/gcc/testsuite/gcc.target/aarch64/simd/vqdmlslh_laneq_s16_1.c
+++ b/gcc/testsuite/gcc.target/aarch64/simd/vqdmlslh_laneq_s16_1.c
@@ -1,27 +1,27 @@
 /* Test the vqdmlslh_laneq_s16 AArch64 SIMD intrinsic.  */
 
 /* { dg-do run } */
-/* { dg-options "-save-temps -O3 -fno-inline" } */
+/* { dg-options "-save-temps -O3" } */
 
 #include "arm_neon.h"
 
 extern void abort (void);
 
+int32_t __attribute__((noipa))
+test_vqdmlslh (int32_t arg1, int16_t arg2, int16x8_t arg3)
+{
+  return vqdmlslh_laneq_s16 (arg1, arg2, arg3, 4);
+}
+
 int
 main (void)
 {
-  int32_t arg1;
-  int16_t arg2;
-  int16x8_t arg3;
   int32_t actual;
   int32_t expected;
 
-  arg1 = -2147450881;
-  arg2 = 32767;
-  arg3 = vcombine_s16 (vcreate_s16 (0x359d7fff00007fffULL),
-                       vcreate_s16 (0xe678ffff00008000ULL));
-
-  actual = vqdmlslh_laneq_s16 (arg1, arg2, arg3, 4);
+  actual = test_vqdmlslh (-2147450881, 32767,
+			  vcombine_s16 (vcreate_s16 (0x359d7fff00007fffULL),
+					vcreate_s16 (0xe678ffff00008000ULL)));
   expected = -32769;
 
   if (expected != actual)
diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vqdmlsls_laneq_s32_1.c b/gcc/testsuite/gcc.target/aarch64/simd/vqdmlsls_laneq_s32_1.c
index e003adb..ff92254 100644
--- a/gcc/testsuite/gcc.target/aarch64/simd/vqdmlsls_laneq_s32_1.c
+++ b/gcc/testsuite/gcc.target/aarch64/simd/vqdmlsls_laneq_s32_1.c
@@ -1,28 +1,27 @@
 /* Test the vqdmlsls_laneq_s32 AArch64 SIMD intrinsic.  */
 
 /* { dg-do run } */
-/* { dg-options "-save-temps -O3 -fno-inline" } */
+/* { dg-options "-save-temps -O3" } */
 
 #include "arm_neon.h"
 
 extern void abort (void);
 
+int64_t __attribute__((noipa))
+test_vqdmlsls (int64_t arg1, int32_t arg2, int32x4_t arg3)
+{
+  return vqdmlsls_laneq_s32 (arg1, arg2, arg3, 3);
+}
+
 int
 main (void)
 {
-  int64_t arg1;
-  int32_t arg2;
-  int32x4_t arg3;
   int64_t actual;
   int64_t expected;
 
-  arg1 = 140733193453567LL;
-  arg2 = 25544;
-  arg3 = vcombine_s32 (vcreate_s32 (0x417b8000ffff8397LL),
-                       vcreate_s32 (0x7fffffff58488000LL));
-
-
-  actual = vqdmlsls_laneq_s32 (arg1, arg2, arg3, 3);
+  actual = test_vqdmlsls (140733193453567LL, 25544,
+			  vcombine_s32 (vcreate_s32 (0x417b8000ffff8397LL),
+					vcreate_s32 (0x7fffffff58488000LL)));
   expected = 31022548895631LL;
 
   if (expected != actual)
diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vqdmulhh_lane_s16.c b/gcc/testsuite/gcc.target/aarch64/simd/vqdmulhh_lane_s16.c
index 75f6770..12b7971 100644
--- a/gcc/testsuite/gcc.target/aarch64/simd/vqdmulhh_lane_s16.c
+++ b/gcc/testsuite/gcc.target/aarch64/simd/vqdmulhh_lane_s16.c
@@ -1,25 +1,26 @@
 /* Test the vqdmulhh_lane_s16 AArch64 SIMD intrinsic.  */
 
 /* { dg-do run } */
-/* { dg-options "-save-temps -O3 -fno-inline" } */
+/* { dg-options "-save-temps -O3" } */
 
 #include "arm_neon.h"
 #include <stdio.h>
 
 extern void abort (void);
 
+int16_t __attribute__((noipa))
+test_vqdmulhh (int16_t arg1, int16x4_t arg2)
+{
+  return vqdmulhh_lane_s16 (arg1, arg2, 2);
+}
+
 int
 main (void)
 {
-  int16_t arg1;
-  int16x4_t arg2;
-  int16_t result;
   int16_t actual;
   int16_t expected;
 
-  arg1 = -32768;
-  arg2 = vcreate_s16 (0x0000ffff2489e398ULL);
-  actual = vqdmulhh_lane_s16 (arg1, arg2, 2);
+  actual = test_vqdmulhh (-32768, vcreate_s16 (0x0000ffff2489e398ULL));
   expected = 1;
 
   if (expected != actual)
diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vqdmulhh_laneq_s16_1.c b/gcc/testsuite/gcc.target/aarch64/simd/vqdmulhh_laneq_s16_1.c
index b3ae37c..1015c68 100644
--- a/gcc/testsuite/gcc.target/aarch64/simd/vqdmulhh_laneq_s16_1.c
+++ b/gcc/testsuite/gcc.target/aarch64/simd/vqdmulhh_laneq_s16_1.c
@@ -1,25 +1,27 @@
 /* Test the vqdmulhh_laneq_s16 AArch64 SIMD intrinsic.  */
 
 /* { dg-do run } */
-/* { dg-options "-save-temps -O3 -fno-inline" } */
+/* { dg-options "-save-temps -O3" } */
 
 #include "arm_neon.h"
 
 extern void abort (void);
 
+int16_t __attribute__((noipa))
+test_vqdmulhh (int16_t arg1, int16x8_t arg2)
+{
+  return vqdmulhh_laneq_s16 (arg1, arg2, 7);
+}
+
 int
 main (void)
 {
-  int16_t arg1;
-  int16x8_t arg2;
   int16_t actual;
   int16_t expected;
 
-  arg1 = 268;
-  arg2 = vcombine_s16 (vcreate_s16 (0xffffffff00000000ULL),
-                       vcreate_s16 (0x0000800018410000ULL));
-
-  actual = vqdmulhh_laneq_s16 (arg1, arg2, 7);
+  actual = test_vqdmulhh (268,
+			  vcombine_s16 (vcreate_s16 (0xffffffff00000000ULL),
+					vcreate_s16 (0x0000800018410000ULL)));
   expected = 0;
 
   if (expected != actual)
diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vqdmulhs_lane_s32.c b/gcc/testsuite/gcc.target/aarch64/simd/vqdmulhs_lane_s32.c
index eef3ac0..f3b297e 100644
--- a/gcc/testsuite/gcc.target/aarch64/simd/vqdmulhs_lane_s32.c
+++ b/gcc/testsuite/gcc.target/aarch64/simd/vqdmulhs_lane_s32.c
@@ -1,25 +1,32 @@
 /* Test the vqdmulhs_lane_s32 AArch64 SIMD intrinsic.  */
 
 /* { dg-do run } */
-/* { dg-options "-save-temps -O3 -fno-inline" } */
+/* { dg-options "-save-temps -O3" } */
 
 #include "arm_neon.h"
 #include <stdio.h>
 
 extern void abort (void);
 
+int32_t __attribute__((noipa))
+test_vqdmulhs_0 (int32_t arg1, int32x2_t arg2)
+{
+  return vqdmulhs_lane_s32 (arg1, arg2, 0);
+}
+
+int32_t __attribute__((noipa))
+test_vqdmulhs_1 (int32_t arg1, int32x2_t arg2)
+{
+  return vqdmulhs_lane_s32 (arg1, arg2, 1);
+}
+
 int
 main (void)
 {
-  int32_t arg1;
-  int32x2_t arg2;
-  int32_t result;
   int32_t actual;
   int32_t expected;
 
-  arg1 = 57336;
-  arg2 = vcreate_s32 (0x55897fff7fff0000ULL);
-  actual = vqdmulhs_lane_s32 (arg1, arg2, 0);
+  actual = test_vqdmulhs_0 (57336, vcreate_s32 (0x55897fff7fff0000ULL));
   expected = 57334;
 
   if (expected != actual)
@@ -28,6 +35,16 @@ main (void)
       abort ();
     }
 
+  actual = test_vqdmulhs_1 (57336, vcreate_s32 (0x55897fff7fff0000ULL));
+  expected = 38315;
+
+  if (expected != actual)
+    {
+      fprintf (stderr, "Expected: %xd, got %xd\n", expected, actual);
+      abort ();
+    }
+
   return 0;
 }
-/* { dg-final { scan-assembler-times "sqdmulh\[ \t\]+\[sS\]\[0-9\]+, ?\[sS\]\[0-9\]+, ?\[vV\]\[0-9\]+\.\[sS\]\\\[0\\\]\n" 1 } } */
+/* { dg-final { scan-assembler-times "sqdmulh\[ \t\]+\[sS\]\[0-9\]+, ?\[sS\]\[0-9\]+, ?(?:\[sS\]\[0-9\]+|\[vV\]\[0-9\]+\.\[sS\]\\\[0\\\])\n" 1 } } */
+/* { dg-final { scan-assembler-times "sqdmulh\[ \t\]+\[sS\]\[0-9\]+, ?\[sS\]\[0-9\]+, ?\[vV\]\[0-9\]+\.\[sS\]\\\[1\\\]\n" 1 } } */
diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vqdmulhs_laneq_s32_1.c b/gcc/testsuite/gcc.target/aarch64/simd/vqdmulhs_laneq_s32_1.c
index 71b2600..fd63bf9 100644
--- a/gcc/testsuite/gcc.target/aarch64/simd/vqdmulhs_laneq_s32_1.c
+++ b/gcc/testsuite/gcc.target/aarch64/simd/vqdmulhs_laneq_s32_1.c
@@ -1,25 +1,27 @@
 /* Test the vqdmulhs_laneq_s32 AArch64 SIMD intrinsic.  */
 
 /* { dg-do run } */
-/* { dg-options "-save-temps -O3 -fno-inline" } */
+/* { dg-options "-save-temps -O3" } */
 
 #include "arm_neon.h"
 
 extern void abort (void);
 
+int32_t __attribute__((noipa))
+test_vqdmulhs (int32_t arg1, int32x4_t arg2)
+{
+  return vqdmulhs_laneq_s32 (arg1, arg2, 3);
+}
+
 int
 main (void)
 {
-  int32_t arg1;
-  int32x4_t arg2;
   int32_t actual;
   int32_t expected;
 
-  arg1 = 0x80000000;
-  arg2 = vcombine_s32 (vcreate_s32 (0x950dffffc4f40000ULL),
-                       vcreate_s32 (0x7fff8000274a8000ULL));
-
-  actual = vqdmulhs_laneq_s32 (arg1, arg2, 3);
+  actual = test_vqdmulhs (0x80000000,
+			  vcombine_s32 (vcreate_s32 (0x950dffffc4f40000ULL),
+					vcreate_s32 (0x7fff8000274a8000ULL)));
   expected = -2147450880;
 
   if (expected != actual)
diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vqrdmulhh_lane_s16.c b/gcc/testsuite/gcc.target/aarch64/simd/vqrdmulhh_lane_s16.c
index aca96d1..7dddb75 100644
--- a/gcc/testsuite/gcc.target/aarch64/simd/vqrdmulhh_lane_s16.c
+++ b/gcc/testsuite/gcc.target/aarch64/simd/vqrdmulhh_lane_s16.c
@@ -1,25 +1,26 @@
 /* Test the vqrdmulhh_lane_s16 AArch64 SIMD intrinsic.  */
 
 /* { dg-do run } */
-/* { dg-options "-save-temps -O3 -fno-inline" } */
+/* { dg-options "-save-temps -O3" } */
 
 #include "arm_neon.h"
 #include <stdio.h>
 
 extern void abort (void);
 
+int16_t __attribute__((noipa))
+test_vqrdmulhh (int16_t arg1, int16x4_t arg2)
+{
+  return vqrdmulhh_lane_s16 (arg1, arg2, 3);
+}
+
 int
 main (void)
 {
-  int16_t arg1;
-  int16x4_t arg2;
-  int16_t result;
   int16_t actual;
   int16_t expected;
 
-  arg1 = -32768;
-  arg2 = vcreate_s16 (0xd78e000005d78000ULL);
-  actual = vqrdmulhh_lane_s16 (arg1, arg2, 3);
+  actual = test_vqrdmulhh (-32768, vcreate_s16 (0xd78e000005d78000ULL));
   expected = 10354;
 
   if (expected != actual)
diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vqrdmulhh_laneq_s16_1.c b/gcc/testsuite/gcc.target/aarch64/simd/vqrdmulhh_laneq_s16_1.c
index fd2c61d..78d6299 100644
--- a/gcc/testsuite/gcc.target/aarch64/simd/vqrdmulhh_laneq_s16_1.c
+++ b/gcc/testsuite/gcc.target/aarch64/simd/vqrdmulhh_laneq_s16_1.c
@@ -1,25 +1,27 @@
 /* Test the vqrdmulhh_laneq_s16 AArch64 SIMD intrinsic.  */
 
 /* { dg-do run } */
-/* { dg-options "-save-temps -O3 -fno-inline" } */
+/* { dg-options "-save-temps -O3" } */
 
 #include "arm_neon.h"
 
 extern void abort (void);
 
+int16_t __attribute__((noipa))
+test_vqrdmulhh (int16_t arg1, int16x8_t arg2)
+{
+  return vqrdmulhh_laneq_s16 (arg1, arg2, 7);
+}
+
 int
 main (void)
 {
-  int16_t arg1;
-  int16x8_t arg2;
   int16_t actual;
   int16_t expected;
 
-  arg1 = 0;
-  arg2 = vcombine_s16 (vcreate_s16 (0x7fffffffa7908000ULL),
-                       vcreate_s16 (0x8000d2607fff0000ULL));
-
-  actual = vqrdmulhh_laneq_s16 (arg1, arg2, 7);
+  actual = test_vqrdmulhh (0,
+			   vcombine_s16 (vcreate_s16 (0x7fffffffa7908000ULL),
+					 vcreate_s16 (0x8000d2607fff0000ULL)));
   expected = 0;
 
   if (expected != actual)
diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vqrdmulhs_lane_s32.c b/gcc/testsuite/gcc.target/aarch64/simd/vqrdmulhs_lane_s32.c
index 30b21c9..827b52f 100644
--- a/gcc/testsuite/gcc.target/aarch64/simd/vqrdmulhs_lane_s32.c
+++ b/gcc/testsuite/gcc.target/aarch64/simd/vqrdmulhs_lane_s32.c
@@ -1,25 +1,26 @@
 /* Test the vqrdmulhs_lane_s32 AArch64 SIMD intrinsic.  */
 
 /* { dg-do run } */
-/* { dg-options "-save-temps -O3 -fno-inline" } */
+/* { dg-options "-save-temps -O3" } */
 
 #include "arm_neon.h"
 #include <stdio.h>
 
 extern void abort (void);
 
+int32_t __attribute__((noipa))
+test_vqrdmulhs (int32_t arg1, int32x2_t arg2)
+{
+  return vqrdmulhs_lane_s32 (arg1, arg2, 1);
+}
+
 int
 main (void)
 {
-  int32_t arg1;
-  int32x2_t arg2;
-  int32_t result;
   int32_t actual;
   int32_t expected;
 
-  arg1 = -2099281921;
-  arg2 = vcreate_s32 (0x000080007fff0000ULL);
-  actual = vqrdmulhs_lane_s32 (arg1, arg2, 1);
+  actual = test_vqrdmulhs (-2099281921, vcreate_s32 (0x000080007fff0000ULL));
   expected = -32033;
 
   if (expected != actual)
diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vqrdmulhs_laneq_s32_1.c b/gcc/testsuite/gcc.target/aarch64/simd/vqrdmulhs_laneq_s32_1.c
index 6d4e764..b06d16f 100644
--- a/gcc/testsuite/gcc.target/aarch64/simd/vqrdmulhs_laneq_s32_1.c
+++ b/gcc/testsuite/gcc.target/aarch64/simd/vqrdmulhs_laneq_s32_1.c
@@ -1,25 +1,27 @@
 /* Test the vqrdmulhs_laneq_s32 AArch64 SIMD intrinsic.  */
 
 /* { dg-do run } */
-/* { dg-options "-save-temps -O3 -fno-inline" } */
+/* { dg-options "-save-temps -O3" } */
 
 #include "arm_neon.h"
 
 extern void abort (void);
 
+int32_t __attribute__((noipa))
+test_vqrdmulhs (int32_t arg1, int32x4_t arg2)
+{
+  return vqrdmulhs_laneq_s32 (arg1, arg2, 3);
+}
+
 int
 main (void)
 {
-  int32_t arg1;
-  int32x4_t arg2;
   int32_t actual;
   int32_t expected;
 
-  arg1 = 32768;
-  arg2 = vcombine_s32 (vcreate_s32 (0x8000ffffffffcd5bULL),
-                       vcreate_s32 (0x7fffffffffffffffULL));
-
-  actual = vqrdmulhs_laneq_s32 (arg1, arg2, 3);
+  actual = test_vqrdmulhs (32768,
+			   vcombine_s32 (vcreate_s32 (0x8000ffffffffcd5bULL),
+					 vcreate_s32 (0x7fffffffffffffffULL)));
   expected = 32768;
 
   if (expected != actual)
diff --git a/gcc/testsuite/gcc.target/aarch64/sve/acle/general-c/sizeless-1.c b/gcc/testsuite/gcc.target/aarch64/sve/acle/general-c/sizeless-1.c
index 4b34a71..01cfd14 100644
--- a/gcc/testsuite/gcc.target/aarch64/sve/acle/general-c/sizeless-1.c
+++ b/gcc/testsuite/gcc.target/aarch64/sve/acle/general-c/sizeless-1.c
@@ -30,8 +30,7 @@ union union1 {
 /* Pointers to sizeless types.  */
 
 svint8_t *global_sve_sc_ptr;
-svint8_t *invalid_sve_sc_ptr = &(svint8_t) { *global_sve_sc_ptr }; /* { dg-error {initializer element is not constant} } */
-  /* { dg-error {SVE type 'svint8_t' does not have a fixed size} "2nd line" { target *-*-* } .-1 } */
+svint8_t *invalid_sve_sc_ptr = &(svint8_t) {};  /* { dg-error {SVE type 'svint8_t' does not have a fixed size} } */
 
 /* Sizeless arguments and return values.  */
 
diff --git a/gcc/testsuite/gcc.target/aarch64/sve/acle/general-c/sizeless-2.c b/gcc/testsuite/gcc.target/aarch64/sve/acle/general-c/sizeless-2.c
index 34dfd59..613b9c4 100644
--- a/gcc/testsuite/gcc.target/aarch64/sve/acle/general-c/sizeless-2.c
+++ b/gcc/testsuite/gcc.target/aarch64/sve/acle/general-c/sizeless-2.c
@@ -30,8 +30,7 @@ union union1 {
 /* Pointers to sizeless types.  */
 
 svint8_t *global_sve_sc_ptr;
-svint8_t *invalid_sve_sc_ptr = &(svint8_t) { *global_sve_sc_ptr }; /* { dg-error {initializer element is not constant} } */
-  /* { dg-error {SVE type 'svint8_t' does not have a fixed size} "2nd line" { target *-*-* } .-1 } */
+svint8_t *invalid_sve_sc_ptr = &(svint8_t) {}; /* { dg-error {SVE type 'svint8_t' does not have a fixed size} } */
 
 /* Sizeless arguments and return values.  */
 
diff --git a/gcc/testsuite/gcc.target/aarch64/sve/cond_asrd_1.c b/gcc/testsuite/gcc.target/aarch64/sve/cond_asrd_1.c
index 478b52a..aac06bd 100644
--- a/gcc/testsuite/gcc.target/aarch64/sve/cond_asrd_1.c
+++ b/gcc/testsuite/gcc.target/aarch64/sve/cond_asrd_1.c
@@ -1,5 +1,5 @@
 /* { dg-do compile } */
-/* { dg-options "-O2 -ftree-vectorize" } */
+/* { dg-options "-O2 -ftree-vectorize -moverride=sve_width=256" } */
 
 #include <stdint.h>
 
diff --git a/gcc/testsuite/gcc.target/aarch64/sve/cond_cnot_4.c b/gcc/testsuite/gcc.target/aarch64/sve/cond_cnot_4.c
index 729d3f4..f627891 100644
--- a/gcc/testsuite/gcc.target/aarch64/sve/cond_cnot_4.c
+++ b/gcc/testsuite/gcc.target/aarch64/sve/cond_cnot_4.c
@@ -1,5 +1,5 @@
 /* { dg-do compile } */
-/* { dg-options "-O2 -ftree-vectorize" } */
+/* { dg-options "-O2 -ftree-vectorize -moverride=sve_width=256" } */
 
 #include <stdint.h>
 
diff --git a/gcc/testsuite/gcc.target/aarch64/sve/cond_cnot_6.c b/gcc/testsuite/gcc.target/aarch64/sve/cond_cnot_6.c
index d44e357..ef1b067 100644
--- a/gcc/testsuite/gcc.target/aarch64/sve/cond_cnot_6.c
+++ b/gcc/testsuite/gcc.target/aarch64/sve/cond_cnot_6.c
@@ -1,5 +1,5 @@
 /* { dg-do compile } */
-/* { dg-options "-O2 -ftree-vectorize" } */
+/* { dg-options "-O2 -ftree-vectorize -moverride=sve_width=256" } */
 
 #include <stdint.h>
 
diff --git a/gcc/testsuite/gcc.target/aarch64/sve/cond_unary_5.c b/gcc/testsuite/gcc.target/aarch64/sve/cond_unary_5.c
index 17b3f86..03a6636 100644
--- a/gcc/testsuite/gcc.target/aarch64/sve/cond_unary_5.c
+++ b/gcc/testsuite/gcc.target/aarch64/sve/cond_unary_5.c
@@ -1,5 +1,5 @@
 /* { dg-do compile } */
-/* { dg-options "-O2 -ftree-vectorize" } */
+/* { dg-options "-O2 -ftree-vectorize -moverride=sve_width=256" } */
 
 #include <stdint.h>
 
diff --git a/gcc/testsuite/gcc.target/aarch64/sve/cond_unary_6.c b/gcc/testsuite/gcc.target/aarch64/sve/cond_unary_6.c
index 1bd342b..c49a304 100644
--- a/gcc/testsuite/gcc.target/aarch64/sve/cond_unary_6.c
+++ b/gcc/testsuite/gcc.target/aarch64/sve/cond_unary_6.c
@@ -1,5 +1,5 @@
 /* { dg-do compile } */
-/* { dg-options "-O2 -ftree-vectorize" } */
+/* { dg-options "-O2 -ftree-vectorize -moverride=sve_width=256" } */
 
 #include <stdint.h>
 
diff --git a/gcc/testsuite/gcc.target/aarch64/sve/cond_uxt_5.c b/gcc/testsuite/gcc.target/aarch64/sve/cond_uxt_5.c
index 1886628..9a2bd8f 100644
--- a/gcc/testsuite/gcc.target/aarch64/sve/cond_uxt_5.c
+++ b/gcc/testsuite/gcc.target/aarch64/sve/cond_uxt_5.c
@@ -1,5 +1,5 @@
 /* { dg-do compile } */
-/* { dg-options "-O2 -ftree-vectorize" } */
+/* { dg-options "-O2 -ftree-vectorize -moverride=sve_width=256" } */
 
 #include <stdint.h>
 
diff --git a/gcc/testsuite/gcc.target/aarch64/sve/cond_xorsign_1.c b/gcc/testsuite/gcc.target/aarch64/sve/cond_xorsign_1.c
new file mode 100644
index 0000000..338ca60
--- /dev/null
+++ b/gcc/testsuite/gcc.target/aarch64/sve/cond_xorsign_1.c
@@ -0,0 +1,34 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+#define xorsign(A, B, SUFFIX) ((A) * __builtin_copysign##SUFFIX (1.0, B))
+
+#define DEF_LOOP(TYPE, SUFFIX)					\
+  void __attribute__ ((noinline, noclone))			\
+  test_##TYPE (TYPE *__restrict r, TYPE *__restrict a,		\
+	       TYPE *__restrict b, TYPE *__restrict c,		\
+	       int n)						\
+  {								\
+    for (int i = 0; i < n; ++i)					\
+      r[i] = a[i] < 20 ? xorsign(b[i], c[i], SUFFIX) : b[i];	\
+  }
+
+#define TEST_ALL(T) \
+  T (_Float16, f16) \
+  T (float, f) \
+  T (double, )
+
+TEST_ALL (DEF_LOOP)
+
+/* { dg-final { scan-assembler-times {\tand\tz[0-9]+\.h, z[0-9]+\.h,} 1 } } */
+/* { dg-final { scan-assembler-times {\tand\tz[0-9]+\.s, z[0-9]+\.s,} 1 } } */
+/* { dg-final { scan-assembler-times {\tand\tz[0-9]+\.d, z[0-9]+\.d,} 1 } } */
+
+/* { dg-final { scan-assembler-times {\teor\tz[0-9]+\.h, p[0-7]/m,} 1 } } */
+/* { dg-final { scan-assembler-times {\teor\tz[0-9]+\.s, p[0-7]/m,} 1 } } */
+/* { dg-final { scan-assembler-times {\teor\tz[0-9]+\.d, p[0-7]/m,} 1 } } */
+
+/* { dg-final { scan-assembler-not {\tfmul} } } */
+/* { dg-final { scan-assembler-not {\tmov\tz[^,]*z} } } */
+/* { dg-final { scan-assembler-not {\tmovprfx\t} } } */
+/* { dg-final { scan-assembler-not {\tsel\t} } } */
diff --git a/gcc/testsuite/gcc.target/aarch64/sve/cond_xorsign_2.c b/gcc/testsuite/gcc.target/aarch64/sve/cond_xorsign_2.c
new file mode 100644
index 0000000..274dd0e
--- /dev/null
+++ b/gcc/testsuite/gcc.target/aarch64/sve/cond_xorsign_2.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -msve-vector-bits=128 --param aarch64-autovec-preference=2" } */
+
+#include "cond_xorsign_1.c"
+
+/* { dg-final { scan-assembler-times {\tand\tz[0-9]+\.h, z[0-9]+\.h,} 1 } } */
+/* { dg-final { scan-assembler-times {\tand\tz[0-9]+\.s, z[0-9]+\.s,} 1 } } */
+/* { dg-final { scan-assembler-times {\tand\tz[0-9]+\.d, z[0-9]+\.d,} 1 } } */
+
+/* { dg-final { scan-assembler-times {\teor\tz[0-9]+\.h, p[0-7]/m,} 1 } } */
+/* { dg-final { scan-assembler-times {\teor\tz[0-9]+\.s, p[0-7]/m,} 1 } } */
+/* { dg-final { scan-assembler-times {\teor\tz[0-9]+\.d, p[0-7]/m,} 1 } } */
+
+/* { dg-final { scan-assembler-not {\tfmul} } } */
+/* { dg-final { scan-assembler-not {\tmov\tz[^,]*z} } } */
+/* { dg-final { scan-assembler-not {\tmovprfx\t} } } */
+/* { dg-final { scan-assembler-not {\tsel\t} } } */
diff --git a/gcc/testsuite/gcc.target/aarch64/sve/slp_13.c b/gcc/testsuite/gcc.target/aarch64/sve/slp_13.c
index 37b5f11..2e8c396 100644
--- a/gcc/testsuite/gcc.target/aarch64/sve/slp_13.c
+++ b/gcc/testsuite/gcc.target/aarch64/sve/slp_13.c
@@ -32,14 +32,11 @@ vec_slp_##TYPE (TYPE *restrict a, int n)			\
 
 TEST_ALL (VEC_PERM)
 
-/* ??? We don't treat the uint loops as SLP.  */
 /* The loop should be fully-masked.  */
-/* { dg-final { scan-assembler-times {\tld1b\t} 2 { xfail *-*-* } } } */
-/* { dg-final { scan-assembler-times {\tld1h\t} 3 { xfail *-*-* } } } */
-/* { dg-final { scan-assembler-times {\tld1w\t} 3 { xfail *-*-* } } } */
-/* { dg-final { scan-assembler-times {\tld1w\t} 2 } } */
-/* { dg-final { scan-assembler-times {\tld1d\t} 3 { xfail *-*-* } } } */
-/* { dg-final { scan-assembler-times {\tld1d\t} 2 } } */
+/* { dg-final { scan-assembler-times {\tld1b\t} 2 } } */
+/* { dg-final { scan-assembler-times {\tld1h\t} 3 } } */
+/* { dg-final { scan-assembler-times {\tld1w\t} 3 } } */
+/* { dg-final { scan-assembler-times {\tld1d\t} 3 } } */
 /* { dg-final { scan-assembler-not {\tldr} } } */
 
 /* { dg-final { scan-assembler-times {\twhilelo\tp[0-7]\.b} 4 } } */
diff --git a/gcc/testsuite/gcc.target/aarch64/sve/vcond_4_costly.c b/gcc/testsuite/gcc.target/aarch64/sve/vcond_4_costly.c
index 4aa567e..76d7a28 100644
--- a/gcc/testsuite/gcc.target/aarch64/sve/vcond_4_costly.c
+++ b/gcc/testsuite/gcc.target/aarch64/sve/vcond_4_costly.c
@@ -61,8 +61,8 @@ TEST_CMP (nuge)
 TEST_CMP (nugt)
 
 /* 2 each for: eq, ne, ueq, nueq.  */
-/* { dg-final { scan-assembler-times {\tfcm(?:eq|ne)\tp[0-9]+\.s, p[0-7]/z, z[0-9]+\.s, z[0-9]+\.s\n} 8 { xfail *-*-* } } } */
-/* { dg-final { scan-assembler-times {\tfcm(?:eq|ne)\tp[0-9]+\.d, p[0-7]/z, z[0-9]+\.d, z[0-9]+\.d\n} 16 { xfail *-*-* } } } */
+/* { dg-final { scan-assembler-times {\tfcm(?:eq|ne)\tp[0-9]+\.s, p[0-7]/z, z[0-9]+\.s, z[0-9]+\.s\n} 8 } } */
+/* { dg-final { scan-assembler-times {\tfcm(?:eq|ne)\tp[0-9]+\.d, p[0-7]/z, z[0-9]+\.d, z[0-9]+\.d\n} 16 } } */
 
 /* 2 each for: olt, ult, nult, ogt, ugt, nugt.  */
 /* { dg-final { scan-assembler-times {\tfcm[lg]t\tp[0-9]+\.s, p[0-7]/z, z[0-9]+\.s, z[0-9]+\.s\n} 12 } } */
diff --git a/gcc/testsuite/gcc.target/aarch64/target_attr_crypto_ice_1.c b/gcc/testsuite/gcc.target/aarch64/target_attr_crypto_ice_1.c
index c74cc90..3b354c0 100644
--- a/gcc/testsuite/gcc.target/aarch64/target_attr_crypto_ice_1.c
+++ b/gcc/testsuite/gcc.target/aarch64/target_attr_crypto_ice_1.c
@@ -6,7 +6,7 @@
 /* Unless we do something about re-laying out the SIMD builtin types
    this testcase ICEs during expansion of the crypto builtin.  */
 
-__attribute__ ((target ("cpu=cortex-a57+crypto")))
+__attribute__ ((target ("cpu=cortex-a57+sha2")))
 uint32x4_t
 test_vsha1cq_u32 (uint32x4_t hash_abcd, uint32_t hash_e, uint32x4_t wk)
 {
diff --git a/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-1.c b/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-1.c
new file mode 100644
index 0000000..122f7a7
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-1.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target mbranch_protection_ok } */
+/* { dg-options "-march=armv8.1-m.main+fp -mbranch-protection=pac-ret+bti -mfloat-abi=hard --save-temps" } */
+
+#if !defined (__ARM_FEATURE_BTI_DEFAULT)
+#error "Feature test macro __ARM_FEATURE_BTI_DEFAULT should be defined."
+#endif
+
+#if !defined (__ARM_FEATURE_PAC_DEFAULT)
+#error "Feature test macro __ARM_FEATURE_PAC_DEFAULT should be defined."
+#endif
+
+/* { dg-final { scan-assembler-not "\.arch_extension pacbti" } } */
+/* { dg-final { scan-assembler "\.eabi_attribute 50, 1" } } */
+/* { dg-final { scan-assembler "\.eabi_attribute 52, 1" } } */
+/* { dg-final { scan-assembler "\.eabi_attribute 74, 1" } } */
+/* { dg-final { scan-assembler "\.eabi_attribute 76, 1" } } */
diff --git a/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-10.c b/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-10.c
new file mode 100644
index 0000000..52d1823
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-10.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target mbranch_protection_ok } */
+/* { dg-additional-options "-march=armv8.1-m.main+fp -mbranch-protection=bti+pac-ret -mfloat-abi=hard" } */
+
+#if (__ARM_FEATURE_BTI_DEFAULT != 1)
+#error "Feature test macro __ARM_FEATURE_BTI_DEFAULT should be defined to 1."
+#endif
+
+#if !defined (__ARM_FEATURE_PAC_DEFAULT)
+#error "Feature test macro __ARM_FEATURE_PAC_DEFAULT should be defined."
+#endif
diff --git a/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-11.c b/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-11.c
new file mode 100644
index 0000000..9f27110
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-11.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+/* { dg-skip-if "avoid conflicting multilib options" { *-*-* } { "-marm" "-mcpu=*" "-mfloat-abi=*" } } */
+/* { dg-options "-march=armv8.1-m.main+pacbti" } */
+
+#if (__ARM_FEATURE_BTI != 1)
+#error "Feature test macro __ARM_FEATURE_BTI_DEFAULT should be defined to 1."
+#endif
+
+#if (__ARM_FEATURE_PAUTH != 1)
+#error "Feature test macro __ARM_FEATURE__PAUTH should be defined to 1."
+#endif
diff --git a/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-12.c b/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-12.c
new file mode 100644
index 0000000..db40b17
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-12.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+/* { dg-skip-if "avoid conflicting multilib options" { *-*-* } { "-marm" "-mcpu=*" } } */
+/* { dg-options "-march=armv8-m.main+fp -mfloat-abi=softfp" } */
+
+#if defined (__ARM_FEATURE_BTI)
+#error "Feature test macro __ARM_FEATURE_BTI should not be defined."
+#endif
+
+#if defined (__ARM_FEATURE_PAUTH)
+#error "Feature test macro __ARM_FEATURE_PAUTH should not be defined."
+#endif
diff --git a/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-2.c b/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-2.c
new file mode 100644
index 0000000..cd418ce
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-2.c
@@ -0,0 +1,24 @@
+/* { dg-do run } */
+/* { dg-require-effective-target mbranch_protection_ok } */
+/* { dg-require-effective-target arm_pacbti_hw } */
+/* { dg-options "-march=armv8.1-m.main+pacbti+fp -mbranch-protection=bti+pac-ret+leaf -mthumb -mfloat-abi=hard" } */
+
+#if !defined (__ARM_FEATURE_BTI_DEFAULT)
+#error "Feature test macro __ARM_FEATURE_BTI_DEFAULT should be defined."
+#endif
+
+#if !defined (__ARM_FEATURE_PAC_DEFAULT)
+#error "Feature test macro __ARM_FEATURE_PAC_DEFAULT should be defined."
+#endif
+
+int
+main()
+{
+  if (__ARM_FEATURE_BTI_DEFAULT != 1)
+    __builtin_abort ();
+
+  if (__ARM_FEATURE_PAC_DEFAULT != 5)
+    __builtin_abort ();
+
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-3.c b/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-3.c
new file mode 100644
index 0000000..b94f344
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-3.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target mbranch_protection_ok } */
+/* { dg-options "-march=armv8.1-m.main+fp -mbranch-protection=pac-ret+leaf -mfloat-abi=hard --save-temps" } */
+
+#if defined (__ARM_FEATURE_BTI_DEFAULT)
+#error "Feature test macro __ARM_FEATURE_BTI_DEFAULT should be undefined."
+#endif
+
+#if !defined (__ARM_FEATURE_PAC_DEFAULT)
+#error "Feature test macro __ARM_FEATURE_PAC_DEFAULT should be defined."
+#endif
+
+/* { dg-final { scan-assembler-not "\.arch_extension pacbti" } } */
+/* { dg-final { scan-assembler "\.eabi_attribute 50, 1" } } */
+/* { dg-final { scan-assembler "\.eabi_attribute 52, 1" } } */
+/* { dg-final { scan-assembler-not "\.eabi_attribute 74" } } */
+/* { dg-final { scan-assembler "\.eabi_attribute 76, 1" } } */
diff --git a/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-4.c b/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-4.c
new file mode 100644
index 0000000..ce4b45a
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-4.c
@@ -0,0 +1,20 @@
+/* { dg-do run } */
+/* { dg-require-effective-target arm_pacbti_hw } */
+/* { dg-options "-march=armv8.1-m.main+pacbti+fp -mbranch-protection=pac-ret -mthumb -mfloat-abi=hard" } */
+
+#if !defined (__ARM_FEATURE_PAC_DEFAULT)
+#error "Feature test macro __ARM_FEATURE_BTI_DEFAULT should be defined."
+#endif
+
+#if defined (__ARM_FEATURE_BTI_DEFAULT)
+#error "Feature test macro __ARM_FEATURE_BTI_DEFAULT should be undefined."
+#endif
+
+int
+main()
+{
+  if (__ARM_FEATURE_PAC_DEFAULT != 1)
+    __builtin_abort ();
+
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-5.c b/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-5.c
new file mode 100644
index 0000000..6d48b7c
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-5.c
@@ -0,0 +1,25 @@
+/* { dg-do run } */
+/* { dg-require-effective-target mbranch_protection_ok } */
+/* { dg-require-effective-target arm_pacbti_hw } */
+/* { dg-skip-if "do not override march" { *-*-* } { "-march=*" } { "-march=armv8.1-m.main" } } */
+/* { dg-additional-options "-march=armv8.1-m.main -mbranch-protection=bti+pac-ret" } */
+
+#if !defined (__ARM_FEATURE_BTI_DEFAULT)
+#error "Feature test macro __ARM_FEATURE_BTI_DEFAULT should be defined."
+#endif
+
+#if !defined (__ARM_FEATURE_PAC_DEFAULT)
+#error "Feature test macro __ARM_FEATURE_PAC_DEFAULT should be defined."
+#endif
+
+int
+main()
+{
+  if (__ARM_FEATURE_BTI_DEFAULT != 1)
+    __builtin_abort ();
+
+  if (__ARM_FEATURE_PAC_DEFAULT != 1)
+    __builtin_abort ();
+
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-6.c b/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-6.c
new file mode 100644
index 0000000..ed52afc
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-6.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target mbranch_protection_ok } */
+/* { dg-additional-options "-march=armv8.1-m.main+fp -mbranch-protection=bti -mfloat-abi=hard --save-temps" } */
+
+#if !defined (__ARM_FEATURE_BTI_DEFAULT)
+#error "Feature test macro __ARM_FEATURE_BTI_DEFAULT should be defined."
+#endif
+
+#if defined (__ARM_FEATURE_PAC_DEFAULT)
+#error "Feature test macro __ARM_FEATURE_PAC_DEFAULT should be undefined."
+#endif
+/* { dg-final { scan-assembler-not "\.arch_extension pacbti" } } */
+/* { dg-final { scan-assembler "\.eabi_attribute 50, 1" } } */
+/* { dg-final { scan-assembler "\.eabi_attribute 52, 1" } } */
+/* { dg-final { scan-assembler "\.eabi_attribute 74, 1" } } */
+/* { dg-final { scan-assembler-not "\.eabi_attribute 76" } } */
diff --git a/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-7.c b/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-7.c
new file mode 100644
index 0000000..1b25907
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-7.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-skip-if "avoid conflicting multilib options" { *-*-* } { "-marm" "-mcpu=*" } } */
+/* { dg-additional-options "-march=armv8.1-m.main+pacbti+fp --save-temps -mfloat-abi=hard" } */
+
+#if defined (__ARM_FEATURE_BTI_DEFAULT)
+#error "Feature test macro __ARM_FEATURE_BTI_DEFAULT should be undefined."
+#endif
+
+#if defined (__ARM_FEATURE_PAC_DEFAULT)
+#error "Feature test macro __ARM_FEATURE_PAC_DEFAULT should be undefined."
+#endif
+
+/* { dg-final { scan-assembler "\.arch_extension pacbti" } } */
+/* { dg-final { scan-assembler "\.eabi_attribute 50, 2" } } */
+/* { dg-final { scan-assembler "\.eabi_attribute 52, 2" } } */
+/* { dg-final { scan-assembler-not "\.eabi_attribute 74" } } */
+/* { dg-final { scan-assembler-not "\.eabi_attribute 76" } } */
diff --git a/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-8.c b/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-8.c
new file mode 100644
index 0000000..3538c18
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-8.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target mbranch_protection_ok } */
+/* { dg-additional-options "-march=armv8.1-m.main+fp -mbranch-protection=bti+pac-ret+leaf -mfloat-abi=hard" } */
+
+#if (__ARM_FEATURE_BTI_DEFAULT != 1)
+#error "Feature test macro __ARM_FEATURE_BTI_DEFAULT should be defined to 1."
+#endif
+
+#if (__ARM_FEATURE_PAC_DEFAULT != 5)
+#error "Feature test macro __ARM_FEATURE_PAC_DEFAULT should be defined to 5."
+#endif
+
diff --git a/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-9.c b/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-9.c
new file mode 100644
index 0000000..27c1c8f
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/acle/pacbti-m-predef-9.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target mbranch_protection_ok } */
+/* { dg-additional-options "-march=armv8.1-m.main+fp -mbranch-protection=pac-ret -mfloat-abi=hard" } */
+
+#if (__ARM_FEATURE_PAC_DEFAULT != 1)
+#error "Feature test macro __ARM_FEATURE_PAC_DEFAULT should be defined to 1."
+#endif
+
+#if defined (__ARM_FEATURE_BTI_DEFAULT)
+#error "Feature test macro __ARM_FEATURE_BTI_DEFAULT should be undefined."
+#endif
diff --git a/gcc/testsuite/gcc.target/arm/bti-1.c b/gcc/testsuite/gcc.target/arm/bti-1.c
new file mode 100644
index 0000000..79dd801
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/bti-1.c
@@ -0,0 +1,12 @@
+/* Check that GCC does bti instruction.  */
+/* { dg-do compile } */
+/* { dg-skip-if "avoid conflicting multilib options" { *-*-* } { "-marm" "-mcpu=*" } } */
+/* { dg-options "-march=armv8.1-m.main -mthumb -mfloat-abi=softfp -mbranch-protection=bti --save-temps" } */
+
+int
+main (void)
+{
+  return 0;
+}
+
+/* { dg-final { scan-assembler "bti" } } */
diff --git a/gcc/testsuite/gcc.target/arm/bti-2.c b/gcc/testsuite/gcc.target/arm/bti-2.c
new file mode 100644
index 0000000..3391056
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/bti-2.c
@@ -0,0 +1,58 @@
+/* { dg-do compile } */
+/* -Os to create jump table.  */
+/* { dg-options "-Os" } */
+/* { dg-skip-if "avoid conflicting multilib options" { *-*-* } { "-marm" "-mcpu=*" } } */
+/* { dg-options "-march=armv8.1-m.main -mthumb -mfloat-abi=softfp -mbranch-protection=bti --save-temps" } */
+
+extern int f1 (void);
+extern int f2 (void);
+extern int f3 (void);
+extern int f4 (void);
+extern int f5 (void);
+extern int f6 (void);
+extern int f7 (void);
+extern int f8 (void);
+extern int f9 (void);
+extern int f10 (void);
+
+int (*ptr) (void);
+
+int
+f_jump_table (int y, int n)
+{
+  int i;
+  for (i = 0; i < n ;i ++)
+  {
+    switch (y)
+      {
+      case 0 : ptr = f1; break;
+      case 1 : ptr = f2; break;
+      case 2 : ptr = f3; break;
+      case 3 : ptr = f4; break;
+      case 4 : ptr = f5; break;
+      case 5 : ptr = f6; break;
+      case 6 : ptr = f7; break;
+      case 7 : ptr = f8; break;
+      case 8 : ptr = f9; break;
+      case 9 : ptr = f10; break;
+      default: break;
+      }
+    y += ptr ();
+  }
+  return (y == 0)? y+1:4;
+}
+
+int
+f_label_address ()
+{
+  static void * addr = &&lab1;
+  goto *addr;
+lab1:
+  addr = &&lab2;
+  return 1;
+lab2:
+  addr = &&lab1;
+  return 2;
+}
+
+/* { dg-final { scan-assembler-times "bti" 15 } } */
diff --git a/gcc/testsuite/gcc.target/arm/multilib.exp b/gcc/testsuite/gcc.target/arm/multilib.exp
index f9bb0d9..d365711 100644
--- a/gcc/testsuite/gcc.target/arm/multilib.exp
+++ b/gcc/testsuite/gcc.target/arm/multilib.exp
@@ -524,6 +524,15 @@ if {[multilib_config "rmprofile"] } {
 	{-mcpu=cortex-m23 -mfpu=fpv5-d16 -mfloat-abi=soft} "thumb/v8-m.base/nofp"
 	{-mcpu=cortex-m33 -mfpu=fpv5-d16 -mfloat-abi=soft} "thumb/v8-m.main/nofp"
 	{-mcpu=cortex-m7+nofp.dp -mfpu=fpv5-d16 -mfloat-abi=soft} "thumb/v7e-m/nofp"
+	{-mcpu=cortex-m85+nopacbti -mfpu=auto -mfloat-abi=soft} "thumb/v8-m.main/nofp"
+	{-mcpu=cortex-m85+nopacbti+nofp -mfpu=auto -mfloat-abi=soft} "thumb/v8-m.main/nofp"
+	{-mcpu=cortex-m85+nopacbti+nomve -mfpu=auto -mfloat-abi=soft} "thumb/v8-m.main/nofp"
+	{-mcpu=cortex-m85+nopacbti+nodsp -mfpu=auto -mfloat-abi=soft} "thumb/v8-m.main/nofp"
+	{-mcpu=cortex-m85+nopacbti+nomve.fp -mfpu=auto -mfloat-abi=soft} "thumb/v8-m.main/nofp"
+	{-mcpu=cortex-m85 -mfpu=auto -mfloat-abi=soft} "thumb/v8-m.main/nofp"
+	{-mcpu=cortex-m85+nomve.fp -mfpu=auto -mfloat-abi=soft} "thumb/v8-m.main/nofp"
+	{-mcpu=cortex-m85+nomve -mfpu=auto -mfloat-abi=soft} "thumb/v8-m.main/nofp"
+	{-mcpu=cortex-m85+nodsp -mfpu=auto -mfloat-abi=soft} "thumb/v8-m.main/nofp"
 	{-mcpu=cortex-m4 -mfpu=auto -mfloat-abi=hard} "thumb/v7e-m+fp/hard"
 	{-mcpu=cortex-m7 -mfpu=auto -mfloat-abi=hard} "thumb/v7e-m+dp/hard"
 	{-mcpu=cortex-m33 -mfpu=auto -mfloat-abi=hard} "thumb/v8-m.main+fp/hard"
@@ -549,6 +558,15 @@ if {[multilib_config "rmprofile"] } {
 	{-mcpu=cortex-m7 -mfpu=fpv5-d16 -mfloat-abi=hard} "thumb/v7e-m+dp/hard"
 	{-mcpu=cortex-m33 -mfpu=fpv5-d16 -mfloat-abi=hard} "thumb/v8-m.main+dp/hard"
 	{-mcpu=cortex-m7+nofp.dp -mfpu=fpv5-d16 -mfloat-abi=hard} "thumb/v7e-m+dp/hard"
+	{-mcpu=cortex-m85+nopacbti -mfpu=auto -mfloat-abi=hard} "thumb/v8-m.main+dp/hard"
+	{-mcpu=cortex-m85+nopacbti+nomve -mfpu=auto -mfloat-abi=hard} "thumb/v8-m.main+dp/hard"
+	{-mcpu=cortex-m85+nopacbti+nodsp -mfpu=auto -mfloat-abi=hard} "thumb/v8-m.main+dp/hard"
+	{-mcpu=cortex-m85+nopacbti+nofp -mfpu=auto -mfloat-abi=hard} "thumb/v8.1-m.main+mve/hard"
+	{-mcpu=cortex-m85+nopacbti+nomve.fp -mfpu=auto -mfloat-abi=hard} "thumb/v8-m.main+dp/hard"
+	{-mcpu=cortex-m85 -mbranch-protection=standard -mfpu=auto -mfloat-abi=hard} "thumb/v8.1-m.main+pacbti+dp/bp/hard"
+	{-mcpu=cortex-m85+nomve -mbranch-protection=standard -mfpu=auto -mfloat-abi=hard} "thumb/v8.1-m.main+pacbti+dp/bp/hard"
+	{-mcpu=cortex-m85+nomve.fp -mbranch-protection=standard -mfpu=auto -mfloat-abi=hard} "thumb/v8.1-m.main+pacbti+dp/bp/hard"
+	{-mcpu=cortex-m85+nodsp -mbranch-protection=standard -mfpu=auto -mfloat-abi=hard} "thumb/v8.1-m.main+pacbti+dp/bp/hard"
 	{-mcpu=cortex-m0 -mfpu=auto -mfloat-abi=softfp} "thumb/v6-m/nofp"
 	{-mcpu=cortex-m1 -mfpu=auto -mfloat-abi=softfp} "thumb/v6-m/nofp"
 	{-mcpu=cortex-m3 -mfpu=auto -mfloat-abi=softfp} "thumb/v7-m/nofp"
@@ -598,6 +616,15 @@ if {[multilib_config "rmprofile"] } {
 	{-mcpu=cortex-m23 -mfpu=fpv5-d16 -mfloat-abi=softfp} "thumb/v8-m.base/nofp"
 	{-mcpu=cortex-m33 -mfpu=fpv5-d16 -mfloat-abi=softfp} "thumb/v8-m.main+dp/softfp"
 	{-mcpu=cortex-m7+nofp.dp -mfpu=fpv5-d16 -mfloat-abi=softfp} "thumb/v7e-m+dp/softfp"
+	{-mcpu=cortex-m85+nopacbti+nofp -mfpu=auto -mfloat-abi=softfp} "thumb/v8-m.main/nofp"
+	{-mcpu=cortex-m85+nopacbti -mfpu=auto -mfloat-abi=softfp} "thumb/v8-m.main+dp/softfp"
+	{-mcpu=cortex-m85+nopacbti+nomve -mfpu=auto -mfloat-abi=softfp} "thumb/v8-m.main+dp/softfp"
+	{-mcpu=cortex-m85+nopacbti+nodsp -mfpu=auto -mfloat-abi=softfp} "thumb/v8-m.main+dp/softfp"
+	{-mcpu=cortex-m85+nopacbti+nomve.fp -mfpu=auto -mfloat-abi=softfp} "thumb/v8-m.main+dp/softfp"
+	{-mcpu=cortex-m85 -mbranch-protection=standard -mfpu=auto -mfloat-abi=softfp} "thumb/v8.1-m.main+pacbti+dp/bp/softfp"
+	{-mcpu=cortex-m85+nomve -mbranch-protection=standard -mfpu=auto -mfloat-abi=softfp} "thumb/v8.1-m.main+pacbti+dp/bp/softfp"
+	{-mcpu=cortex-m85+nomve.fp -mbranch-protection=standard -mfpu=auto -mfloat-abi=softfp} "thumb/v8.1-m.main+pacbti+dp/bp/softfp"
+	{-mcpu=cortex-m85+nodsp -mbranch-protection=standard -mfpu=auto -mfloat-abi=softfp} "thumb/v8.1-m.main+pacbti+dp/bp/softfp"
 	{-march=armv6-m -mfpu=auto -mfloat-abi=soft} "thumb/v6-m/nofp"
 	{-march=armv7-m -mfpu=auto -mfloat-abi=soft} "thumb/v7-m/nofp"
 	{-march=armv7e-m -mfpu=auto -mfloat-abi=soft} "thumb/v7e-m/nofp"
@@ -838,6 +865,12 @@ if {[multilib_config "rmprofile"] } {
 	{-march=armv8.1-m.main+mve.fp+fp.dp -mfpu=auto -mfloat-abi=softfp} "thumb/v8-m.main+dp/softfp"
 	{-march=armv8.1-m.main+mve+fp.dp -mfpu=auto -mfloat-abi=hard} "thumb/v8-m.main+dp/hard"
 	{-march=armv8.1-m.main+mve.fp+fp.dp -mfpu=auto -mfloat-abi=hard} "thumb/v8-m.main+dp/hard"
+	{-march=armv8.1-m.main+pacbti -mbranch-protection=standard -mfloat-abi=soft} "thumb/v8.1-m.main+pacbti/bp/nofp"
+	{-march=armv8.1-m.main+pacbti+fp -mbranch-protection=standard -mfloat-abi=softfp} "thumb/v8.1-m.main+pacbti+fp/bp/softfp"
+	{-march=armv8.1-m.main+pacbti+fp -mbranch-protection=standard -mfloat-abi=hard} "thumb/v8.1-m.main+pacbti+fp/bp/hard"
+	{-march=armv8.1-m.main+pacbti+fp.dp -mbranch-protection=standard -mfloat-abi=softfp} "thumb/v8.1-m.main+pacbti+dp/bp/softfp"
+	{-march=armv8.1-m.main+pacbti+fp.dp -mbranch-protection=standard -mfloat-abi=hard} "thumb/v8.1-m.main+pacbti+dp/bp/hard"
+	{-march=armv8.1-m.main+pacbti+mve -mbranch-protection=standard -mfloat-abi=hard} "thumb/v8.1-m.main+pacbti+mve/bp/hard"
 	{-mcpu=cortex-m55+nomve -mfpu=auto -mfloat-abi=soft} "thumb/v8-m.main/nofp"
 	{-mcpu=cortex-m55+nomve -mfpu=auto -mfloat-abi=softfp} "thumb/v8-m.main+dp/softfp"
 	{-mcpu=cortex-m55+nomve -mfpu=auto -mfloat-abi=hard} "thumb/v8-m.main+dp/hard"
diff --git a/gcc/testsuite/gcc.target/arm/mve/general/preserve_user_namespace_1.c b/gcc/testsuite/gcc.target/arm/mve/general/preserve_user_namespace_1.c
new file mode 100644
index 0000000..f107ac4
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/mve/general/preserve_user_namespace_1.c
@@ -0,0 +1,6 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target arm_v8_1m_mve_ok } */
+/* { dg-add-options arm_v8_1m_mve } */
+
+#define __ARM_MVE_PRESERVE_USER_NAMESPACE
+#include <arm_mve.h>
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/mve_intrinsic_type_overloads-fp.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/mve_intrinsic_type_overloads-fp.c
new file mode 100644
index 0000000..7492e9b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/mve_intrinsic_type_overloads-fp.c
@@ -0,0 +1,65 @@
+/* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
+/* { dg-add-options arm_v8_1m_mve_fp } */
+/* { dg-additional-options "-O2 -Wno-pedantic -Wno-long-long" } */
+#include "arm_mve.h"
+
+float f1;
+double f2;
+float16_t f3;
+float32_t f4;
+__fp16 f5;
+_Float16 f6;
+
+int i1;
+short i2;
+long i3;
+long long i4;
+int8_t i5;
+int16_t i6;
+int32_t i7;
+int64_t i8;
+
+const int ci1;
+const short ci2;
+const long ci3;
+const long long ci4;
+const int8_t ci5;
+const int16_t ci6;
+const int32_t ci7;
+const int64_t ci8;
+
+float16x8_t floatvec;
+int16x8_t intvec;
+
+void test(void)
+{
+    /* Test a few different supported ways of passing an int value.  The
+    intrinsic vmulq was chosen arbitrarily, but it is representative of
+    all intrinsics that take a non-const scalar value.  */
+    intvec = vmulq(intvec, 2);
+    intvec = vmulq(intvec, (int32_t) 2);
+    intvec = vmulq(intvec, (short) 2);
+    intvec = vmulq(intvec, i1);
+    intvec = vmulq(intvec, i2);
+    intvec = vmulq(intvec, i3);
+    intvec = vmulq(intvec, i4);
+    intvec = vmulq(intvec, i5);
+    intvec = vmulq(intvec, i6);
+    intvec = vmulq(intvec, i7);
+    intvec = vmulq(intvec, i8);
+
+    /* Test a few different supported ways of passing a float value.  */
+    floatvec = vmulq(floatvec, 0.5);
+    floatvec = vmulq(floatvec, 0.5f);
+    floatvec = vmulq(floatvec, (__fp16) 0.5);
+    floatvec = vmulq(floatvec, f1);
+    floatvec = vmulq(floatvec, f2);
+    floatvec = vmulq(floatvec, f3);
+    floatvec = vmulq(floatvec, f4);
+    floatvec = vmulq(floatvec, f5);
+    floatvec = vmulq(floatvec, f6);
+    floatvec = vmulq(floatvec, 0.15f16);
+    floatvec = vmulq(floatvec, (_Float16) 0.15);
+}
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/mve_intrinsic_type_overloads-int.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/mve_intrinsic_type_overloads-int.c
new file mode 100644
index 0000000..9a921bf
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/mve_intrinsic_type_overloads-int.c
@@ -0,0 +1,45 @@
+/* { dg-require-effective-target arm_v8_1m_mve_ok } */
+/* { dg-add-options arm_v8_1m_mve } */
+/* { dg-additional-options "-O2 -Wno-pedantic -Wno-long-long" } */
+
+#include "arm_mve.h"
+
+int i1;
+short i2;
+long i3;
+long long i4;
+int8_t i5;
+int16_t i6;
+int32_t i7;
+int64_t i8;
+
+const int ci1;
+const short ci2;
+const long ci3;
+const long long ci4;
+const int8_t ci5;
+const int16_t ci6;
+const int32_t ci7;
+const int64_t ci8;
+
+int16x8_t intvec;
+
+void test(void)
+{
+    /* Test a few different supported ways of passing an int value.  The
+    intrinsic vmulq was chosen arbitrarily, but it is representative of
+    all intrinsics that take a non-const scalar value.  */
+    intvec = vmulq(intvec, 2);
+    intvec = vmulq(intvec, (int32_t) 2);
+    intvec = vmulq(intvec, (short) 2);
+    intvec = vmulq(intvec, i1);
+    intvec = vmulq(intvec, i2);
+    intvec = vmulq(intvec, i3);
+    intvec = vmulq(intvec, i4);
+    intvec = vmulq(intvec, i5);
+    intvec = vmulq(intvec, i6);
+    intvec = vmulq(intvec, i7);
+    intvec = vmulq(intvec, i8);
+}
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_f16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_f16.c
index b50a5d5..fb83a1c 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_f16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_f16.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vcadd.f16	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo (float16x8_t a, float16x8_t b)
 {
   return vcaddq_rot270_f16 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcadd.f16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vcadd.f16	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo1 (float16x8_t a, float16x8_t b)
 {
   return vcaddq_rot270 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcadd.f16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_f32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_f32.c
index 0a12ff6..f8341a7 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_f32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_f32.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vcadd.f32	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo (float32x4_t a, float32x4_t b)
 {
   return vcaddq_rot270_f32 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcadd.f32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vcadd.f32	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo1 (float32x4_t a, float32x4_t b)
 {
   return vcaddq_rot270 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcadd.f32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_f16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_f16.c
index e78bbd5..b4e2ffd 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_f16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_f16.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.f16	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo (float16x8_t inactive, float16x8_t a, float16x8_t b, mve_pred16_t p)
 {
   return vcaddq_rot270_m_f16 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.f16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.f16	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo1 (float16x8_t inactive, float16x8_t a, float16x8_t b, mve_pred16_t p)
 {
   return vcaddq_rot270_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.f16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_f32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_f32.c
index 8b53c66..e7adc1b 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_f32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_f32.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.f32	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo (float32x4_t inactive, float32x4_t a, float32x4_t b, mve_pred16_t p)
 {
   return vcaddq_rot270_m_f32 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.f32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.f32	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo1 (float32x4_t inactive, float32x4_t a, float32x4_t b, mve_pred16_t p)
 {
   return vcaddq_rot270_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.f32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_s16.c
index 61948bb..fdde2f5 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_s16.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i16	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t inactive, int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vcaddq_rot270_m_s16 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i16	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t inactive, int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vcaddq_rot270_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_s32.c
index 0bbe24b..1cb6afb 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_s32.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i32	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t inactive, int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vcaddq_rot270_m_s32 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i32	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t inactive, int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vcaddq_rot270_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_s8.c
index e9cab3d..39f0639 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_s8.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i8	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t inactive, int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vcaddq_rot270_m_s8 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i8	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t inactive, int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vcaddq_rot270_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_u16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_u16.c
index 25c7125..fd28528 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_u16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_u16.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i16	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo (uint16x8_t inactive, uint16x8_t a, uint16x8_t b, mve_pred16_t p)
 {
   return vcaddq_rot270_m_u16 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i16	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo1 (uint16x8_t inactive, uint16x8_t a, uint16x8_t b, mve_pred16_t p)
 {
   return vcaddq_rot270_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_u32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_u32.c
index ee437ee..053a611 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_u32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_u32.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i32	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo (uint32x4_t inactive, uint32x4_t a, uint32x4_t b, mve_pred16_t p)
 {
   return vcaddq_rot270_m_u32 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i32	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo1 (uint32x4_t inactive, uint32x4_t a, uint32x4_t b, mve_pred16_t p)
 {
   return vcaddq_rot270_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_u8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_u8.c
index 419ba7e..869983a 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_u8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_m_u8.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i8	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 uint8x16_t
 foo (uint8x16_t inactive, uint8x16_t a, uint8x16_t b, mve_pred16_t p)
 {
   return vcaddq_rot270_m_u8 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i8	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 uint8x16_t
 foo1 (uint8x16_t inactive, uint8x16_t a, uint8x16_t b, mve_pred16_t p)
 {
   return vcaddq_rot270_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_s16.c
index 832be00..67b0d0a 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_s16.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vcadd.i16	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t a, int16x8_t b)
 {
   return vcaddq_rot270_s16 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcadd.i16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vcadd.i16	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t a, int16x8_t b)
 {
   return vcaddq_rot270 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcadd.i16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_s32.c
index dbebe22..ab28458 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_s32.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vcadd.i32	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t a, int32x4_t b)
 {
   return vcaddq_rot270_s32 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcadd.i32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vcadd.i32	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t a, int32x4_t b)
 {
   return vcaddq_rot270 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcadd.i32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_s8.c
index 5f7852f..842d6ad 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_s8.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vcadd.i8	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t a, int8x16_t b)
 {
   return vcaddq_rot270_s8 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcadd.i8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vcadd.i8	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t a, int8x16_t b)
 {
   return vcaddq_rot270 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcadd.i8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_u16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_u16.c
index 80b6c0f..97773d8 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_u16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_u16.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vcadd.i16	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo (uint16x8_t a, uint16x8_t b)
 {
   return vcaddq_rot270_u16 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcadd.i16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vcadd.i16	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo1 (uint16x8_t a, uint16x8_t b)
 {
   return vcaddq_rot270 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcadd.i16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_u32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_u32.c
index 260c5b8..17d5c14 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_u32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_u32.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vcadd.i32	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo (uint32x4_t a, uint32x4_t b)
 {
   return vcaddq_rot270_u32 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcadd.i32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vcadd.i32	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo1 (uint32x4_t a, uint32x4_t b)
 {
   return vcaddq_rot270 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcadd.i32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_u8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_u8.c
index ae9c4f4..faf01a1 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_u8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_u8.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vcadd.i8	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 uint8x16_t
 foo (uint8x16_t a, uint8x16_t b)
 {
   return vcaddq_rot270_u8 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcadd.i8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vcadd.i8	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 uint8x16_t
 foo1 (uint8x16_t a, uint8x16_t b)
 {
   return vcaddq_rot270 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcadd.i8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_f16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_f16.c
index 4b99c63..f35aaf0 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_f16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_f16.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.f16	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo (float16x8_t a, float16x8_t b, mve_pred16_t p)
 {
   return vcaddq_rot270_x_f16 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.f16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.f16	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo1 (float16x8_t a, float16x8_t b, mve_pred16_t p)
 {
   return vcaddq_rot270_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_f32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_f32.c
index 2532ef7..6446d9e 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_f32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_f32.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.f32	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo (float32x4_t a, float32x4_t b, mve_pred16_t p)
 {
   return vcaddq_rot270_x_f32 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.f32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.f32	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo1 (float32x4_t a, float32x4_t b, mve_pred16_t p)
 {
   return vcaddq_rot270_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_s16.c
index 676efa8..b92fd2e 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_s16.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i16	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vcaddq_rot270_x_s16 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i16	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vcaddq_rot270_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_s32.c
index 9aa05d5..b8acc67 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_s32.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i32	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vcaddq_rot270_x_s32 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i32	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vcaddq_rot270_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_s8.c
index 4532296..78ec786 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_s8.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i8	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vcaddq_rot270_x_s8 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i8	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vcaddq_rot270_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_u16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_u16.c
index 51db937..ea78162 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_u16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_u16.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i16	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo (uint16x8_t a, uint16x8_t b, mve_pred16_t p)
 {
   return vcaddq_rot270_x_u16 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i16	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo1 (uint16x8_t a, uint16x8_t b, mve_pred16_t p)
 {
   return vcaddq_rot270_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_u32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_u32.c
index a2e51c1..a43d806 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_u32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_u32.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i32	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo (uint32x4_t a, uint32x4_t b, mve_pred16_t p)
 {
   return vcaddq_rot270_x_u32 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i32	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo1 (uint32x4_t a, uint32x4_t b, mve_pred16_t p)
 {
   return vcaddq_rot270_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_u8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_u8.c
index 6ae7f69..eb9cf0c 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_u8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot270_x_u8.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i8	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 uint8x16_t
 foo (uint8x16_t a, uint8x16_t b, mve_pred16_t p)
 {
   return vcaddq_rot270_x_u8 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i8	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 uint8x16_t
 foo1 (uint8x16_t a, uint8x16_t b, mve_pred16_t p)
 {
   return vcaddq_rot270_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_f16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_f16.c
index e1b21e6..1e78bd1 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_f16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_f16.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vcadd.f16	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo (float16x8_t a, float16x8_t b)
 {
   return vcaddq_rot90_f16 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcadd.f16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vcadd.f16	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo1 (float16x8_t a, float16x8_t b)
 {
   return vcaddq_rot90 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcadd.f16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_f32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_f32.c
index 118489e..9611f89 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_f32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_f32.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vcadd.f32	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo (float32x4_t a, float32x4_t b)
 {
   return vcaddq_rot90_f32 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcadd.f32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vcadd.f32	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo1 (float32x4_t a, float32x4_t b)
 {
   return vcaddq_rot90 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcadd.f32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_f16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_f16.c
index e47e242..58608b4 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_f16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_f16.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.f16	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo (float16x8_t inactive, float16x8_t a, float16x8_t b, mve_pred16_t p)
 {
   return vcaddq_rot90_m_f16 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.f16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.f16	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo1 (float16x8_t inactive, float16x8_t a, float16x8_t b, mve_pred16_t p)
 {
   return vcaddq_rot90_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.f16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_f32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_f32.c
index 833aa9c..125dbe5 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_f32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_f32.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.f32	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo (float32x4_t inactive, float32x4_t a, float32x4_t b, mve_pred16_t p)
 {
   return vcaddq_rot90_m_f32 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.f32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.f32	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo1 (float32x4_t inactive, float32x4_t a, float32x4_t b, mve_pred16_t p)
 {
   return vcaddq_rot90_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.f32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_s16.c
index 46babedb..38e0e47 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_s16.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i16	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t inactive, int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vcaddq_rot90_m_s16 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i16	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t inactive, int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vcaddq_rot90_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_s32.c
index 15774e5..455d838 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_s32.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i32	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t inactive, int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vcaddq_rot90_m_s32 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i32	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t inactive, int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vcaddq_rot90_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_s8.c
index 6f2bb4d..7217dad 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_s8.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i8	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t inactive, int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vcaddq_rot90_m_s8 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i8	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t inactive, int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vcaddq_rot90_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_u16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_u16.c
index b9113fe..d3edbaa 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_u16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_u16.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i16	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo (uint16x8_t inactive, uint16x8_t a, uint16x8_t b, mve_pred16_t p)
 {
   return vcaddq_rot90_m_u16 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i16	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo1 (uint16x8_t inactive, uint16x8_t a, uint16x8_t b, mve_pred16_t p)
 {
   return vcaddq_rot90_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_u32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_u32.c
index b7fe510..eb1bf2a 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_u32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_u32.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i32	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo (uint32x4_t inactive, uint32x4_t a, uint32x4_t b, mve_pred16_t p)
 {
   return vcaddq_rot90_m_u32 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i32	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo1 (uint32x4_t inactive, uint32x4_t a, uint32x4_t b, mve_pred16_t p)
 {
   return vcaddq_rot90_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_u8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_u8.c
index e6c4e9f..3343399 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_u8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_m_u8.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i8	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 uint8x16_t
 foo (uint8x16_t inactive, uint8x16_t a, uint8x16_t b, mve_pred16_t p)
 {
   return vcaddq_rot90_m_u8 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i8	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 uint8x16_t
 foo1 (uint8x16_t inactive, uint8x16_t a, uint8x16_t b, mve_pred16_t p)
 {
   return vcaddq_rot90_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_s16.c
index 8279da9..134fba6 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_s16.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vcadd.i16	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t a, int16x8_t b)
 {
   return vcaddq_rot90_s16 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcadd.i16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vcadd.i16	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t a, int16x8_t b)
 {
   return vcaddq_rot90 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcadd.i16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_s32.c
index 6d59da7..b8e8167 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_s32.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vcadd.i32	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t a, int32x4_t b)
 {
   return vcaddq_rot90_s32 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcadd.i32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vcadd.i32	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t a, int32x4_t b)
 {
   return vcaddq_rot90 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcadd.i32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_s8.c
index b4f5a22..2a37b8e 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_s8.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vcadd.i8	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t a, int8x16_t b)
 {
   return vcaddq_rot90_s8 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcadd.i8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vcadd.i8	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t a, int8x16_t b)
 {
   return vcaddq_rot90 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcadd.i8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_u16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_u16.c
index e203bd0..51e1871 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_u16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_u16.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vcadd.i16	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo (uint16x8_t a, uint16x8_t b)
 {
   return vcaddq_rot90_u16 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcadd.i16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vcadd.i16	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo1 (uint16x8_t a, uint16x8_t b)
 {
   return vcaddq_rot90 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcadd.i16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_u32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_u32.c
index 0cba5d5..5905062 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_u32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_u32.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vcadd.i32	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo (uint32x4_t a, uint32x4_t b)
 {
   return vcaddq_rot90_u32 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcadd.i32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vcadd.i32	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo1 (uint32x4_t a, uint32x4_t b)
 {
   return vcaddq_rot90 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcadd.i32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_u8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_u8.c
index f4f0476..3737463 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_u8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_u8.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vcadd.i8	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 uint8x16_t
 foo (uint8x16_t a, uint8x16_t b)
 {
   return vcaddq_rot90_u8 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcadd.i8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vcadd.i8	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 uint8x16_t
 foo1 (uint8x16_t a, uint8x16_t b)
 {
   return vcaddq_rot90 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcadd.i8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_f16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_f16.c
index 476648a..4223c4d 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_f16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_f16.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.f16	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo (float16x8_t a, float16x8_t b, mve_pred16_t p)
 {
   return vcaddq_rot90_x_f16 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.f16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.f16	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo1 (float16x8_t a, float16x8_t b, mve_pred16_t p)
 {
   return vcaddq_rot90_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_f32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_f32.c
index ae9a196..9e67c56 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_f32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_f32.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.f32	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo (float32x4_t a, float32x4_t b, mve_pred16_t p)
 {
   return vcaddq_rot90_x_f32 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.f32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.f32	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo1 (float32x4_t a, float32x4_t b, mve_pred16_t p)
 {
   return vcaddq_rot90_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_s16.c
index 16b5949..553fc28 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_s16.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i16	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vcaddq_rot90_x_s16 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i16	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vcaddq_rot90_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_s32.c
index d30150e..1cd7338 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_s32.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i32	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vcaddq_rot90_x_s32 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i32	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vcaddq_rot90_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_s8.c
index fa79ce2..13373d4 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_s8.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i8	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vcaddq_rot90_x_s8 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i8	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vcaddq_rot90_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_u16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_u16.c
index e18a39e..3f89577 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_u16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_u16.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i16	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo (uint16x8_t a, uint16x8_t b, mve_pred16_t p)
 {
   return vcaddq_rot90_x_u16 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i16	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo1 (uint16x8_t a, uint16x8_t b, mve_pred16_t p)
 {
   return vcaddq_rot90_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_u32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_u32.c
index b9b95fe..34cb036 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_u32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_u32.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i32	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo (uint32x4_t a, uint32x4_t b, mve_pred16_t p)
 {
   return vcaddq_rot90_x_u32 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i32	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo1 (uint32x4_t a, uint32x4_t b, mve_pred16_t p)
 {
   return vcaddq_rot90_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_u8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_u8.c
index b8b8978..d383404 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_u8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcaddq_rot90_x_u8.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i8	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 uint8x16_t
 foo (uint8x16_t a, uint8x16_t b, mve_pred16_t p)
 {
   return vcaddq_rot90_x_u8 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcaddt.i8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcaddt.i8	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 uint8x16_t
 foo1 (uint8x16_t a, uint8x16_t b, mve_pred16_t p)
 {
   return vcaddq_rot90_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_m_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_m_s16.c
index d0eb700..1996ac8 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_m_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_m_s16.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclst.s16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t inactive, int16x8_t a, mve_pred16_t p)
 {
   return vclsq_m_s16 (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vclst.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclst.s16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t inactive, int16x8_t a, mve_pred16_t p)
 {
   return vclsq_m (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_m_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_m_s32.c
index b6d7088..f51841d 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_m_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_m_s32.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclst.s32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t inactive, int32x4_t a, mve_pred16_t p)
 {
   return vclsq_m_s32 (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vclst.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclst.s32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t inactive, int32x4_t a, mve_pred16_t p)
 {
   return vclsq_m (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_m_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_m_s8.c
index 28d4d96..2975c4c 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_m_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_m_s8.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclst.s8	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t inactive, int8x16_t a, mve_pred16_t p)
 {
   return vclsq_m_s8 (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vclst.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclst.s8	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t inactive, int8x16_t a, mve_pred16_t p)
 {
   return vclsq_m (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_s16.c
index e57fbb9..ed1b5c7 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_s16.c
@@ -1,21 +1,41 @@
-/* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
-/* { dg-add-options arm_v8_1m_mve_fp } */
+/* { dg-require-effective-target arm_v8_1m_mve_ok } */
+/* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vcls.s16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t a)
 {
   return vclsq_s16 (a);
 }
 
-/* { dg-final { scan-assembler "vcls.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vcls.s16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t a)
 {
   return vclsq (a);
 }
 
-/* { dg-final { scan-assembler "vcls.s16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_s32.c
index 7fa3038..9e5369e 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_s32.c
@@ -1,21 +1,41 @@
-/* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
-/* { dg-add-options arm_v8_1m_mve_fp } */
+/* { dg-require-effective-target arm_v8_1m_mve_ok } */
+/* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vcls.s32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t a)
 {
   return vclsq_s32 (a);
 }
 
-/* { dg-final { scan-assembler "vcls.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vcls.s32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t a)
 {
   return vclsq (a);
 }
 
-/* { dg-final { scan-assembler "vcls.s32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_s8.c
index b098548..c4a9468 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_s8.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vcls.s8	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t a)
 {
   return vclsq_s8 (a);
 }
 
-/* { dg-final { scan-assembler "vcls.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vcls.s8	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t a)
 {
   return vclsq (a);
 }
 
-/* { dg-final { scan-assembler "vcls.s8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_x_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_x_s16.c
index ab09c99..ea11ece 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_x_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_x_s16.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclst.s16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t a, mve_pred16_t p)
 {
   return vclsq_x_s16 (a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vclst.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclst.s16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t a, mve_pred16_t p)
 {
   return vclsq_x (a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_x_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_x_s32.c
index 09a8dab..1737c56 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_x_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_x_s32.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclst.s32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t a, mve_pred16_t p)
 {
   return vclsq_x_s32 (a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vclst.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclst.s32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t a, mve_pred16_t p)
 {
   return vclsq_x (a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_x_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_x_s8.c
index af40f7f..a7cdb61 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_x_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclsq_x_s8.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclst.s8	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t a, mve_pred16_t p)
 {
   return vclsq_x_s8 (a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vclst.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclst.s8	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t a, mve_pred16_t p)
 {
   return vclsq_x (a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_m_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_m_s16.c
index 9670f8f..620314e 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_m_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_m_s16.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclzt.i16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t inactive, int16x8_t a, mve_pred16_t p)
 {
   return vclzq_m_s16 (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vclzt.i16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclzt.i16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t inactive, int16x8_t a, mve_pred16_t p)
 {
   return vclzq_m (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_m_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_m_s32.c
index 1842735..dfda1e67 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_m_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_m_s32.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclzt.i32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t inactive, int32x4_t a, mve_pred16_t p)
 {
   return vclzq_m_s32 (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vclzt.i32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclzt.i32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t inactive, int32x4_t a, mve_pred16_t p)
 {
   return vclzq_m (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_m_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_m_s8.c
index 2697d03..1300fe6 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_m_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_m_s8.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclzt.i8	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t inactive, int8x16_t a, mve_pred16_t p)
 {
   return vclzq_m_s8 (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vclzt.i8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclzt.i8	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t inactive, int8x16_t a, mve_pred16_t p)
 {
   return vclzq_m (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_m_u16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_m_u16.c
index 8405b16..922819d 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_m_u16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_m_u16.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclzt.i16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo (uint16x8_t inactive, uint16x8_t a, mve_pred16_t p)
 {
   return vclzq_m_u16 (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vclzt.i16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclzt.i16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo1 (uint16x8_t inactive, uint16x8_t a, mve_pred16_t p)
 {
   return vclzq_m (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_m_u32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_m_u32.c
index 350e6e7..6e75a04 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_m_u32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_m_u32.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclzt.i32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo (uint32x4_t inactive, uint32x4_t a, mve_pred16_t p)
 {
   return vclzq_m_u32 (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vclzt.i32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclzt.i32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo1 (uint32x4_t inactive, uint32x4_t a, mve_pred16_t p)
 {
   return vclzq_m (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_m_u8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_m_u8.c
index d455526..3c450e8 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_m_u8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_m_u8.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclzt.i8	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint8x16_t
 foo (uint8x16_t inactive, uint8x16_t a, mve_pred16_t p)
 {
   return vclzq_m_u8 (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vclzt.i8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclzt.i8	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint8x16_t
 foo1 (uint8x16_t inactive, uint8x16_t a, mve_pred16_t p)
 {
   return vclzq_m (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_s16.c
index f71a0a4..17be53f 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_s16.c
@@ -1,21 +1,41 @@
-/* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
-/* { dg-add-options arm_v8_1m_mve_fp } */
+/* { dg-require-effective-target arm_v8_1m_mve_ok } */
+/* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vclz.i16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t a)
 {
   return vclzq_s16 (a);
 }
 
-/* { dg-final { scan-assembler "vclz.i16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vclz.i16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t a)
 {
   return vclzq (a);
 }
 
-/* { dg-final { scan-assembler "vclz.i16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_s32.c
index 46a002b..5e440fe 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_s32.c
@@ -1,21 +1,41 @@
-/* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
-/* { dg-add-options arm_v8_1m_mve_fp } */
+/* { dg-require-effective-target arm_v8_1m_mve_ok } */
+/* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vclz.i32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t a)
 {
   return vclzq_s32 (a);
 }
 
-/* { dg-final { scan-assembler "vclz.i32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vclz.i32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t a)
 {
   return vclzq (a);
 }
 
-/* { dg-final { scan-assembler "vclz.i32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_s8.c
index 3cab6f3..9eaa9a4 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_s8.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vclz.i8	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t a)
 {
   return vclzq_s8 (a);
 }
 
-/* { dg-final { scan-assembler "vclz.i8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vclz.i8	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t a)
 {
   return vclzq (a);
 }
 
-/* { dg-final { scan-assembler "vclz.i8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_u16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_u16.c
index cada68b..37179b2 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_u16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_u16.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vclz.i16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo (uint16x8_t a)
 {
-    return vclzq_u16 (a);
+  return vclzq_u16 (a);
 }
 
-/* { dg-final { scan-assembler "vclz.i16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vclz.i16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo1 (uint16x8_t a)
 {
-    return vclzq (a);
+  return vclzq (a);
+}
+
+#ifdef __cplusplus
 }
+#endif
 
-/* { dg-final { scan-assembler "vclz.i16"  }  } */
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_u32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_u32.c
index 0291b0c..65ee44d 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_u32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_u32.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vclz.i32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo (uint32x4_t a)
 {
-    return vclzq_u32 (a);
+  return vclzq_u32 (a);
 }
 
-/* { dg-final { scan-assembler "vclz.i32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vclz.i32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo1 (uint32x4_t a)
 {
-    return vclzq (a);
+  return vclzq (a);
+}
+
+#ifdef __cplusplus
 }
+#endif
 
-/* { dg-final { scan-assembler "vclz.i32"  }  } */
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_u8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_u8.c
index 5eb7bab..bed4ab1 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_u8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_u8.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vclz.i8	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint8x16_t
 foo (uint8x16_t a)
 {
-    return vclzq_u8 (a);
+  return vclzq_u8 (a);
 }
 
-/* { dg-final { scan-assembler "vclz.i8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vclz.i8	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint8x16_t
 foo1 (uint8x16_t a)
 {
-    return vclzq (a);
+  return vclzq (a);
+}
+
+#ifdef __cplusplus
 }
+#endif
 
-/* { dg-final { scan-assembler "vclz.i8"  }  } */
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_x_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_x_s16.c
index daddd1b..ea78bf2 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_x_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_x_s16.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclzt.i16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t a, mve_pred16_t p)
 {
   return vclzq_x_s16 (a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vclzt.i16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclzt.i16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t a, mve_pred16_t p)
 {
   return vclzq_x (a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_x_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_x_s32.c
index d4f443f..cc85d4d 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_x_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_x_s32.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclzt.i32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t a, mve_pred16_t p)
 {
   return vclzq_x_s32 (a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vclzt.i32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclzt.i32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t a, mve_pred16_t p)
 {
   return vclzq_x (a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_x_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_x_s8.c
index b33d2c5..0f80916 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_x_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_x_s8.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclzt.i8	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t a, mve_pred16_t p)
 {
   return vclzq_x_s8 (a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vclzt.i8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclzt.i8	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t a, mve_pred16_t p)
 {
   return vclzq_x (a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_x_u16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_x_u16.c
index 6d9bc79..a9b662d 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_x_u16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_x_u16.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclzt.i16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo (uint16x8_t a, mve_pred16_t p)
 {
   return vclzq_x_u16 (a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vclzt.i16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclzt.i16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo1 (uint16x8_t a, mve_pred16_t p)
 {
   return vclzq_x (a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_x_u32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_x_u32.c
index c3b053b..5446938 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_x_u32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_x_u32.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclzt.i32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo (uint32x4_t a, mve_pred16_t p)
 {
   return vclzq_x_u32 (a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vclzt.i32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclzt.i32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo1 (uint32x4_t a, mve_pred16_t p)
 {
   return vclzq_x (a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_x_u8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_x_u8.c
index 678b2eb..548a74e 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_x_u8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vclzq_x_u8.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclzt.i8	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint8x16_t
 foo (uint8x16_t a, mve_pred16_t p)
 {
   return vclzq_x_u8 (a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vclzt.i8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vclzt.i8	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint8x16_t
 foo1 (uint8x16_t a, mve_pred16_t p)
 {
   return vclzq_x (a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_f16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_f16.c
index fa7d0c0..bb8a997 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_f16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_f16.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vcmla.f16	q[0-9]+, q[0-9]+, q[0-9]+, #0(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo (float16x8_t a, float16x8_t b, float16x8_t c)
 {
   return vcmlaq_f16 (a, b, c);
 }
 
-/* { dg-final { scan-assembler "vcmla.f16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vcmla.f16	q[0-9]+, q[0-9]+, q[0-9]+, #0(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo1 (float16x8_t a, float16x8_t b, float16x8_t c)
 {
   return vcmlaq (a, b, c);
 }
 
-/* { dg-final { scan-assembler "vcmla.f16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_f32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_f32.c
index 166bf42..71ec4b84 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_f32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_f32.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vcmla.f32	q[0-9]+, q[0-9]+, q[0-9]+, #0(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo (float32x4_t a, float32x4_t b, float32x4_t c)
 {
   return vcmlaq_f32 (a, b, c);
 }
 
-/* { dg-final { scan-assembler "vcmla.f32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vcmla.f32	q[0-9]+, q[0-9]+, q[0-9]+, #0(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo1 (float32x4_t a, float32x4_t b, float32x4_t c)
 {
   return vcmlaq (a, b, c);
 }
 
-/* { dg-final { scan-assembler "vcmla.f32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_m_f16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_m_f16.c
index 0929f5a..3db345d 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_m_f16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_m_f16.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmlat.f16	q[0-9]+, q[0-9]+, q[0-9]+, #0(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo (float16x8_t a, float16x8_t b, float16x8_t c, mve_pred16_t p)
 {
   return vcmlaq_m_f16 (a, b, c, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmlat.f16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmlat.f16	q[0-9]+, q[0-9]+, q[0-9]+, #0(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo1 (float16x8_t a, float16x8_t b, float16x8_t c, mve_pred16_t p)
 {
   return vcmlaq_m (a, b, c, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmlat.f16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_m_f32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_m_f32.c
index 1f4ba45..dcbd2dc 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_m_f32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_m_f32.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmlat.f32	q[0-9]+, q[0-9]+, q[0-9]+, #0(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo (float32x4_t a, float32x4_t b, float32x4_t c, mve_pred16_t p)
 {
   return vcmlaq_m_f32 (a, b, c, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmlat.f32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmlat.f32	q[0-9]+, q[0-9]+, q[0-9]+, #0(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo1 (float32x4_t a, float32x4_t b, float32x4_t c, mve_pred16_t p)
 {
   return vcmlaq_m (a, b, c, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmlat.f32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot180_f16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot180_f16.c
index fc6ba30..f76ae23 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot180_f16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot180_f16.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vcmla.f16	q[0-9]+, q[0-9]+, q[0-9]+, #180(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo (float16x8_t a, float16x8_t b, float16x8_t c)
 {
   return vcmlaq_rot180_f16 (a, b, c);
 }
 
-/* { dg-final { scan-assembler "vcmla.f16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vcmla.f16	q[0-9]+, q[0-9]+, q[0-9]+, #180(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo1 (float16x8_t a, float16x8_t b, float16x8_t c)
 {
   return vcmlaq_rot180 (a, b, c);
 }
 
-/* { dg-final { scan-assembler "vcmla.f16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot180_f32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot180_f32.c
index dbe3f26..c97d0d0 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot180_f32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot180_f32.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vcmla.f32	q[0-9]+, q[0-9]+, q[0-9]+, #180(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo (float32x4_t a, float32x4_t b, float32x4_t c)
 {
   return vcmlaq_rot180_f32 (a, b, c);
 }
 
-/* { dg-final { scan-assembler "vcmla.f32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vcmla.f32	q[0-9]+, q[0-9]+, q[0-9]+, #180(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo1 (float32x4_t a, float32x4_t b, float32x4_t c)
 {
   return vcmlaq_rot180 (a, b, c);
 }
 
-/* { dg-final { scan-assembler "vcmla.f32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot180_m_f16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot180_m_f16.c
index 84a3bd8..132cdf9 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot180_m_f16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot180_m_f16.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmlat.f16	q[0-9]+, q[0-9]+, q[0-9]+, #180(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo (float16x8_t a, float16x8_t b, float16x8_t c, mve_pred16_t p)
 {
   return vcmlaq_rot180_m_f16 (a, b, c, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmlat.f16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmlat.f16	q[0-9]+, q[0-9]+, q[0-9]+, #180(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo1 (float16x8_t a, float16x8_t b, float16x8_t c, mve_pred16_t p)
 {
   return vcmlaq_rot180_m (a, b, c, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmlat.f16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot180_m_f32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot180_m_f32.c
index 61f5716..99e96eb 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot180_m_f32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot180_m_f32.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmlat.f32	q[0-9]+, q[0-9]+, q[0-9]+, #180(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo (float32x4_t a, float32x4_t b, float32x4_t c, mve_pred16_t p)
 {
   return vcmlaq_rot180_m_f32 (a, b, c, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmlat.f32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmlat.f32	q[0-9]+, q[0-9]+, q[0-9]+, #180(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo1 (float32x4_t a, float32x4_t b, float32x4_t c, mve_pred16_t p)
 {
   return vcmlaq_rot180_m (a, b, c, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmlat.f32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot270_f16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot270_f16.c
index 1b0bef9..fae8510 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot270_f16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot270_f16.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vcmla.f16	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo (float16x8_t a, float16x8_t b, float16x8_t c)
 {
   return vcmlaq_rot270_f16 (a, b, c);
 }
 
-/* { dg-final { scan-assembler "vcmla.f16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vcmla.f16	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo1 (float16x8_t a, float16x8_t b, float16x8_t c)
 {
   return vcmlaq_rot270 (a, b, c);
 }
 
-/* { dg-final { scan-assembler "vcmla.f16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot270_f32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot270_f32.c
index 83e1502..54a9b66 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot270_f32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot270_f32.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vcmla.f32	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo (float32x4_t a, float32x4_t b, float32x4_t c)
 {
   return vcmlaq_rot270_f32 (a, b, c);
 }
 
-/* { dg-final { scan-assembler "vcmla.f32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vcmla.f32	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo1 (float32x4_t a, float32x4_t b, float32x4_t c)
 {
   return vcmlaq_rot270 (a, b, c);
 }
 
-/* { dg-final { scan-assembler "vcmla.f32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot270_m_f16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot270_m_f16.c
index 6e033b1..e34f831 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot270_m_f16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot270_m_f16.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmlat.f16	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo (float16x8_t a, float16x8_t b, float16x8_t c, mve_pred16_t p)
 {
   return vcmlaq_rot270_m_f16 (a, b, c, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmlat.f16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmlat.f16	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo1 (float16x8_t a, float16x8_t b, float16x8_t c, mve_pred16_t p)
 {
   return vcmlaq_rot270_m (a, b, c, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmlat.f16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot270_m_f32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot270_m_f32.c
index 4928341..cdba91b 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot270_m_f32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot270_m_f32.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmlat.f32	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo (float32x4_t a, float32x4_t b, float32x4_t c, mve_pred16_t p)
 {
   return vcmlaq_rot270_m_f32 (a, b, c, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmlat.f32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmlat.f32	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo1 (float32x4_t a, float32x4_t b, float32x4_t c, mve_pred16_t p)
 {
   return vcmlaq_rot270_m (a, b, c, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmlat.f32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot90_f16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot90_f16.c
index 16744a4..f767b2b 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot90_f16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot90_f16.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vcmla.f16	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo (float16x8_t a, float16x8_t b, float16x8_t c)
 {
   return vcmlaq_rot90_f16 (a, b, c);
 }
 
-/* { dg-final { scan-assembler "vcmla.f16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vcmla.f16	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo1 (float16x8_t a, float16x8_t b, float16x8_t c)
 {
   return vcmlaq_rot90 (a, b, c);
 }
 
-/* { dg-final { scan-assembler "vcmla.f16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot90_f32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot90_f32.c
index f1f19a8..6c9b24f 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot90_f32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot90_f32.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vcmla.f32	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo (float32x4_t a, float32x4_t b, float32x4_t c)
 {
   return vcmlaq_rot90_f32 (a, b, c);
 }
 
-/* { dg-final { scan-assembler "vcmla.f32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vcmla.f32	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo1 (float32x4_t a, float32x4_t b, float32x4_t c)
 {
   return vcmlaq_rot90 (a, b, c);
 }
 
-/* { dg-final { scan-assembler "vcmla.f32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot90_m_f16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot90_m_f16.c
index 7133ddc..9141c9e 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot90_m_f16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot90_m_f16.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmlat.f16	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo (float16x8_t a, float16x8_t b, float16x8_t c, mve_pred16_t p)
 {
   return vcmlaq_rot90_m_f16 (a, b, c, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmlat.f16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmlat.f16	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo1 (float16x8_t a, float16x8_t b, float16x8_t c, mve_pred16_t p)
 {
   return vcmlaq_rot90_m (a, b, c, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmlat.f16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot90_m_f32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot90_m_f32.c
index 6022e3b..f317d41 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot90_m_f32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmlaq_rot90_m_f32.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmlat.f32	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo (float32x4_t a, float32x4_t b, float32x4_t c, mve_pred16_t p)
 {
   return vcmlaq_rot90_m_f32 (a, b, c, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmlat.f32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmlat.f32	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo1 (float32x4_t a, float32x4_t b, float32x4_t c, mve_pred16_t p)
 {
   return vcmlaq_rot90_m (a, b, c, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmlat.f32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_f16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_f16.c
index 142c315..456370e 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_f16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_f16.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vcmul.f16	q[0-9]+, q[0-9]+, q[0-9]+, #0(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo (float16x8_t a, float16x8_t b)
 {
   return vcmulq_f16 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcmul.f16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vcmul.f16	q[0-9]+, q[0-9]+, q[0-9]+, #0(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo1 (float16x8_t a, float16x8_t b)
 {
   return vcmulq (a, b);
 }
 
-/* { dg-final { scan-assembler "vcmul.f16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_f32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_f32.c
index 158d750..64db652 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_f32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_f32.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vcmul.f32	q[0-9]+, q[0-9]+, q[0-9]+, #0(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo (float32x4_t a, float32x4_t b)
 {
   return vcmulq_f32 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcmul.f32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vcmul.f32	q[0-9]+, q[0-9]+, q[0-9]+, #0(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo1 (float32x4_t a, float32x4_t b)
 {
   return vcmulq (a, b);
 }
 
-/* { dg-final { scan-assembler "vcmul.f32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_m_f16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_m_f16.c
index b38e0d9..b60f5d7 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_m_f16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_m_f16.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmult.f16	q[0-9]+, q[0-9]+, q[0-9]+, #0(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo (float16x8_t inactive, float16x8_t a, float16x8_t b, mve_pred16_t p)
 {
   return vcmulq_m_f16 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmult.f16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmult.f16	q[0-9]+, q[0-9]+, q[0-9]+, #0(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo1 (float16x8_t inactive, float16x8_t a, float16x8_t b, mve_pred16_t p)
 {
   return vcmulq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmult.f16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_m_f32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_m_f32.c
index 7bf6873..22157d4 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_m_f32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_m_f32.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmult.f32	q[0-9]+, q[0-9]+, q[0-9]+, #0(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo (float32x4_t inactive, float32x4_t a, float32x4_t b, mve_pred16_t p)
 {
   return vcmulq_m_f32 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmult.f32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmult.f32	q[0-9]+, q[0-9]+, q[0-9]+, #0(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo1 (float32x4_t inactive, float32x4_t a, float32x4_t b, mve_pred16_t p)
 {
   return vcmulq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmult.f32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot180_f16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot180_f16.c
index fc7162a..f01b0f3 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot180_f16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot180_f16.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vcmul.f16	q[0-9]+, q[0-9]+, q[0-9]+, #180(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo (float16x8_t a, float16x8_t b)
 {
   return vcmulq_rot180_f16 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcmul.f16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vcmul.f16	q[0-9]+, q[0-9]+, q[0-9]+, #180(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo1 (float16x8_t a, float16x8_t b)
 {
   return vcmulq_rot180 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcmul.f16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot180_f32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot180_f32.c
index 13a4553..537385c 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot180_f32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot180_f32.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vcmul.f32	q[0-9]+, q[0-9]+, q[0-9]+, #180(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo (float32x4_t a, float32x4_t b)
 {
   return vcmulq_rot180_f32 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcmul.f32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vcmul.f32	q[0-9]+, q[0-9]+, q[0-9]+, #180(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo1 (float32x4_t a, float32x4_t b)
 {
   return vcmulq_rot180 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcmul.f32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot180_m_f16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot180_m_f16.c
index 8767e2b..bc8692e 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot180_m_f16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot180_m_f16.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmult.f16	q[0-9]+, q[0-9]+, q[0-9]+, #180(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo (float16x8_t inactive, float16x8_t a, float16x8_t b, mve_pred16_t p)
 {
   return vcmulq_rot180_m_f16 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmult.f16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmult.f16	q[0-9]+, q[0-9]+, q[0-9]+, #180(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo1 (float16x8_t inactive, float16x8_t a, float16x8_t b, mve_pred16_t p)
 {
   return vcmulq_rot180_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmult.f16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot180_m_f32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot180_m_f32.c
index 3f95103..d2a0b6d 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot180_m_f32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot180_m_f32.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmult.f32	q[0-9]+, q[0-9]+, q[0-9]+, #180(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo (float32x4_t inactive, float32x4_t a, float32x4_t b, mve_pred16_t p)
 {
   return vcmulq_rot180_m_f32 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmult.f32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmult.f32	q[0-9]+, q[0-9]+, q[0-9]+, #180(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo1 (float32x4_t inactive, float32x4_t a, float32x4_t b, mve_pred16_t p)
 {
   return vcmulq_rot180_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmult.f32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot180_x_f16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot180_x_f16.c
index f8e835f..37d7b79 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot180_x_f16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot180_x_f16.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmult.f16	q[0-9]+, q[0-9]+, q[0-9]+, #180(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo (float16x8_t a, float16x8_t b, mve_pred16_t p)
 {
   return vcmulq_rot180_x_f16 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmult.f16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmult.f16	q[0-9]+, q[0-9]+, q[0-9]+, #180(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo1 (float16x8_t a, float16x8_t b, mve_pred16_t p)
 {
   return vcmulq_rot180_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot180_x_f32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot180_x_f32.c
index d0d30c5..1e57fba 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot180_x_f32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot180_x_f32.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmult.f32	q[0-9]+, q[0-9]+, q[0-9]+, #180(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo (float32x4_t a, float32x4_t b, mve_pred16_t p)
 {
   return vcmulq_rot180_x_f32 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmult.f32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmult.f32	q[0-9]+, q[0-9]+, q[0-9]+, #180(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo1 (float32x4_t a, float32x4_t b, mve_pred16_t p)
 {
   return vcmulq_rot180_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot270_f16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot270_f16.c
index 225b8910..05c444a 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot270_f16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot270_f16.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vcmul.f16	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo (float16x8_t a, float16x8_t b)
 {
   return vcmulq_rot270_f16 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcmul.f16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vcmul.f16	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo1 (float16x8_t a, float16x8_t b)
 {
   return vcmulq_rot270 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcmul.f16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot270_f32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot270_f32.c
index 1c8b0eb..b599c9f 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot270_f32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot270_f32.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vcmul.f32	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo (float32x4_t a, float32x4_t b)
 {
   return vcmulq_rot270_f32 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcmul.f32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vcmul.f32	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo1 (float32x4_t a, float32x4_t b)
 {
   return vcmulq_rot270 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcmul.f32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot270_m_f16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot270_m_f16.c
index 20ccb5e..fded8a0 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot270_m_f16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot270_m_f16.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmult.f16	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo (float16x8_t inactive, float16x8_t a, float16x8_t b, mve_pred16_t p)
 {
   return vcmulq_rot270_m_f16 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmult.f16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmult.f16	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo1 (float16x8_t inactive, float16x8_t a, float16x8_t b, mve_pred16_t p)
 {
   return vcmulq_rot270_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmult.f16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot270_m_f32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot270_m_f32.c
index 7499f42..54d939e 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot270_m_f32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot270_m_f32.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmult.f32	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo (float32x4_t inactive, float32x4_t a, float32x4_t b, mve_pred16_t p)
 {
   return vcmulq_rot270_m_f32 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmult.f32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmult.f32	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo1 (float32x4_t inactive, float32x4_t a, float32x4_t b, mve_pred16_t p)
 {
   return vcmulq_rot270_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmult.f32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot270_x_f16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot270_x_f16.c
index d1b52e7..d1e58cb 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot270_x_f16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot270_x_f16.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmult.f16	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo (float16x8_t a, float16x8_t b, mve_pred16_t p)
 {
   return vcmulq_rot270_x_f16 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmult.f16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmult.f16	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo1 (float16x8_t a, float16x8_t b, mve_pred16_t p)
 {
   return vcmulq_rot270_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot270_x_f32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot270_x_f32.c
index 35da593..07c781f 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot270_x_f32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot270_x_f32.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmult.f32	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo (float32x4_t a, float32x4_t b, mve_pred16_t p)
 {
   return vcmulq_rot270_x_f32 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmult.f32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmult.f32	q[0-9]+, q[0-9]+, q[0-9]+, #270(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo1 (float32x4_t a, float32x4_t b, mve_pred16_t p)
 {
   return vcmulq_rot270_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot90_f16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot90_f16.c
index 17f96cb..53b1930 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot90_f16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot90_f16.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vcmul.f16	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo (float16x8_t a, float16x8_t b)
 {
   return vcmulq_rot90_f16 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcmul.f16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vcmul.f16	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo1 (float16x8_t a, float16x8_t b)
 {
   return vcmulq_rot90 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcmul.f16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot90_f32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot90_f32.c
index 739fc9c..147f180 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot90_f32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot90_f32.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vcmul.f32	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo (float32x4_t a, float32x4_t b)
 {
   return vcmulq_rot90_f32 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcmul.f32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vcmul.f32	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo1 (float32x4_t a, float32x4_t b)
 {
   return vcmulq_rot90 (a, b);
 }
 
-/* { dg-final { scan-assembler "vcmul.f32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot90_m_f16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot90_m_f16.c
index 8259baa..8c4b090 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot90_m_f16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot90_m_f16.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmult.f16	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo (float16x8_t inactive, float16x8_t a, float16x8_t b, mve_pred16_t p)
 {
   return vcmulq_rot90_m_f16 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmult.f16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmult.f16	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo1 (float16x8_t inactive, float16x8_t a, float16x8_t b, mve_pred16_t p)
 {
   return vcmulq_rot90_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmult.f16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot90_m_f32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot90_m_f32.c
index 751a9a6..b3131a5 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot90_m_f32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot90_m_f32.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmult.f32	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo (float32x4_t inactive, float32x4_t a, float32x4_t b, mve_pred16_t p)
 {
   return vcmulq_rot90_m_f32 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmult.f32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmult.f32	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo1 (float32x4_t inactive, float32x4_t a, float32x4_t b, mve_pred16_t p)
 {
   return vcmulq_rot90_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmult.f32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot90_x_f16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot90_x_f16.c
index c4aef6c..0006103 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot90_x_f16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot90_x_f16.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmult.f16	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo (float16x8_t a, float16x8_t b, mve_pred16_t p)
 {
   return vcmulq_rot90_x_f16 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmult.f16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmult.f16	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo1 (float16x8_t a, float16x8_t b, mve_pred16_t p)
 {
   return vcmulq_rot90_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmult.f16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot90_x_f32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot90_x_f32.c
index 9c54f08..8e31ad5 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot90_x_f32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_rot90_x_f32.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmult.f32	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo (float32x4_t a, float32x4_t b, mve_pred16_t p)
 {
   return vcmulq_rot90_x_f32 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmult.f32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmult.f32	q[0-9]+, q[0-9]+, q[0-9]+, #90(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo1 (float32x4_t a, float32x4_t b, mve_pred16_t p)
 {
   return vcmulq_rot90_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmult.f32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_x_f16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_x_f16.c
index 7634d61..b533247 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_x_f16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_x_f16.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmult.f16	q[0-9]+, q[0-9]+, q[0-9]+, #0(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo (float16x8_t a, float16x8_t b, mve_pred16_t p)
 {
   return vcmulq_x_f16 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmult.f16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmult.f16	q[0-9]+, q[0-9]+, q[0-9]+, #0(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo1 (float16x8_t a, float16x8_t b, mve_pred16_t p)
 {
   return vcmulq_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_x_f32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_x_f32.c
index 21b6acf..a73482a 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_x_f32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vcmulq_x_f32.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmult.f32	q[0-9]+, q[0-9]+, q[0-9]+, #0(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo (float32x4_t a, float32x4_t b, mve_pred16_t p)
 {
   return vcmulq_x_f32 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vcmult.f32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vcmult.f32	q[0-9]+, q[0-9]+, q[0-9]+, #0(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo1 (float32x4_t a, float32x4_t b, mve_pred16_t p)
 {
   return vcmulq_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_n_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_n_s16.c
index 20a999d..31f78b3 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_n_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_n_s16.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (int16x8_t a, int16_t b)
   return vhaddq (a, b);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_n_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_n_s32.c
index 986cb8d..77c0521 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_n_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_n_s32.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (int32x4_t a, int32_t b)
   return vhaddq (a, b);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_n_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_n_s8.c
index 57a4b36..1cf93d5 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_n_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_n_s8.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (int8x16_t a, int8_t b)
   return vhaddq (a, b);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_n_u16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_n_u16.c
index abed33b..98d80e4 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_n_u16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_n_u16.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -42,4 +46,8 @@ foo2 (uint16x8_t a)
   return vhaddq (a, 1);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_n_u32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_n_u32.c
index 5e5204f..9b7e611 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_n_u32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_n_u32.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -42,4 +46,8 @@ foo2 (uint32x4_t a)
   return vhaddq (a, 1);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_n_u8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_n_u8.c
index b35221e..4d82970 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_n_u8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_n_u8.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -42,4 +46,8 @@ foo2 (uint8x16_t a)
   return vhaddq (a, 1);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_s16.c
index 310964f..2788eb2 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_s16.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (int16x8_t a, int16x8_t b)
   return vhaddq (a, b);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_s32.c
index d822264..67872a7 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_s32.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (int32x4_t a, int32x4_t b)
   return vhaddq (a, b);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_s8.c
index 85b2fee..1ec8905 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_s8.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (int8x16_t a, int8x16_t b)
   return vhaddq (a, b);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_u16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_u16.c
index 2da0aa0..bc84618 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_u16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_u16.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (uint16x8_t a, uint16x8_t b)
   return vhaddq (a, b);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_u32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_u32.c
index 49b865a..6abdfce 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_u32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_u32.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (uint32x4_t a, uint32x4_t b)
   return vhaddq (a, b);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_u8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_u8.c
index 5ecd3cb..0c68c68 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_u8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_u8.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (uint8x16_t a, uint8x16_t b)
   return vhaddq (a, b);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_n_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_n_s16.c
index a4e277d..d5bff94 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_n_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_n_s16.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -38,4 +42,8 @@ foo1 (int16x8_t a, int16_t b, mve_pred16_t p)
   return vhaddq_x (a, b, p);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_n_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_n_s32.c
index c79b88d..af3e219 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_n_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_n_s32.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -38,4 +42,8 @@ foo1 (int32x4_t a, int32_t b, mve_pred16_t p)
   return vhaddq_x (a, b, p);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_n_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_n_s8.c
index 6189353..a4551e2 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_n_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_n_s8.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -38,4 +42,8 @@ foo1 (int8x16_t a, int8_t b, mve_pred16_t p)
   return vhaddq_x (a, b, p);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_n_u16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_n_u16.c
index 146d226..71facc4 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_n_u16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_n_u16.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -54,4 +58,8 @@ foo2 (uint16x8_t a, mve_pred16_t p)
   return vhaddq_x (a, 1, p);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_n_u32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_n_u32.c
index b70014f..d45421c 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_n_u32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_n_u32.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -54,4 +58,8 @@ foo2 (uint32x4_t a, mve_pred16_t p)
   return vhaddq_x (a, 1, p);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_n_u8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_n_u8.c
index 03978df..5f16fbd 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_n_u8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_n_u8.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -54,4 +58,8 @@ foo2 (uint8x16_t a, mve_pred16_t p)
   return vhaddq_x (a, 1, p);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_s16.c
index c3c7875..4e33273 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_s16.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -38,4 +42,8 @@ foo1 (int16x8_t a, int16x8_t b, mve_pred16_t p)
   return vhaddq_x (a, b, p);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_s32.c
index a1ab196..5cdfd39 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_s32.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -38,4 +42,8 @@ foo1 (int32x4_t a, int32x4_t b, mve_pred16_t p)
   return vhaddq_x (a, b, p);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_s8.c
index 061ae89..7a2ed23 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_s8.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -38,4 +42,8 @@ foo1 (int8x16_t a, int8x16_t b, mve_pred16_t p)
   return vhaddq_x (a, b, p);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_u16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_u16.c
index 0ee8852..e24ff16 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_u16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_u16.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -38,4 +42,8 @@ foo1 (uint16x8_t a, uint16x8_t b, mve_pred16_t p)
   return vhaddq_x (a, b, p);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_u32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_u32.c
index 0a0e512..e9f1395 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_u32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_u32.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -38,4 +42,8 @@ foo1 (uint32x4_t a, uint32x4_t b, mve_pred16_t p)
   return vhaddq_x (a, b, p);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_u8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_u8.c
index c495641..cba0a30 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_u8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhaddq_x_u8.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -38,4 +42,8 @@ foo1 (uint8x16_t a, uint8x16_t b, mve_pred16_t p)
   return vhaddq_x (a, b, p);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_n_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_n_s16.c
index af4f534..4d1bab9 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_n_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_n_s16.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (int16x8_t a, int16_t b)
   return vhsubq (a, b);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_n_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_n_s32.c
index 941d380..8effffa 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_n_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_n_s32.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (int32x4_t a, int32_t b)
   return vhsubq (a, b);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_n_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_n_s8.c
index 9ceb4ef..f55cd8f 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_n_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_n_s8.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (int8x16_t a, int8_t b)
   return vhsubq (a, b);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_n_u16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_n_u16.c
index 037ed2c..73575a4 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_n_u16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_n_u16.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -42,4 +46,8 @@ foo2 (uint16x8_t a)
   return vhsubq (a, 1);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_n_u32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_n_u32.c
index f51eb10..f152ef1 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_n_u32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_n_u32.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -42,4 +46,8 @@ foo2 (uint32x4_t a)
   return vhsubq (a, 1);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_n_u8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_n_u8.c
index 24dd45d..0a58b1e 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_n_u8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_n_u8.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -42,4 +46,8 @@ foo2 (uint8x16_t a)
   return vhsubq (a, 1);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_s16.c
index 0f275d4..ec8d9aa 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_s16.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (int16x8_t a, int16x8_t b)
   return vhsubq (a, b);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_s32.c
index 21aeb9d..e98635a 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_s32.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (int32x4_t a, int32x4_t b)
   return vhsubq (a, b);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_s8.c
index b3ee943..3107bb5 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_s8.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (int8x16_t a, int8x16_t b)
   return vhsubq (a, b);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_u16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_u16.c
index 690ef2d..783309f 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_u16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_u16.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (uint16x8_t a, uint16x8_t b)
   return vhsubq (a, b);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_u32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_u32.c
index cfe1257..99bc278 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_u32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_u32.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (uint32x4_t a, uint32x4_t b)
   return vhsubq (a, b);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_u8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_u8.c
index 1926bc3..ae18651 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_u8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_u8.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (uint8x16_t a, uint8x16_t b)
   return vhsubq (a, b);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_n_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_n_s16.c
index fcda4c5..260ba9e 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_n_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_n_s16.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -38,4 +42,8 @@ foo1 (int16x8_t a, int16_t b, mve_pred16_t p)
   return vhsubq_x (a, b, p);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_n_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_n_s32.c
index 5563722..be5cc04 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_n_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_n_s32.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -38,4 +42,8 @@ foo1 (int32x4_t a, int32_t b, mve_pred16_t p)
   return vhsubq_x (a, b, p);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_n_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_n_s8.c
index ecfe188..b0c28be 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_n_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_n_s8.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -38,4 +42,8 @@ foo1 (int8x16_t a, int8_t b, mve_pred16_t p)
   return vhsubq_x (a, b, p);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_n_u16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_n_u16.c
index bf3d6c3..f31bb3f 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_n_u16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_n_u16.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -54,4 +58,8 @@ foo2 (uint16x8_t a, mve_pred16_t p)
   return vhsubq_x (a, 1, p);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_n_u32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_n_u32.c
index 4ae75b0..a35346d 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_n_u32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_n_u32.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -54,4 +58,8 @@ foo2 (uint32x4_t a, mve_pred16_t p)
   return vhsubq_x (a, 1, p);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_n_u8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_n_u8.c
index edfa421..25c8544 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_n_u8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_n_u8.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -54,4 +58,8 @@ foo2 (uint8x16_t a, mve_pred16_t p)
   return vhsubq_x (a, 1, p);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_s16.c
index bd2771b..dc3433c 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_s16.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -38,4 +42,8 @@ foo1 (int16x8_t a, int16x8_t b, mve_pred16_t p)
   return vhsubq_x (a, b, p);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_s32.c
index 0ea40df..a1e1fae 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_s32.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -38,4 +42,8 @@ foo1 (int32x4_t a, int32x4_t b, mve_pred16_t p)
   return vhsubq_x (a, b, p);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_s8.c
index 90ee94d..bbfce81 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_s8.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -38,4 +42,8 @@ foo1 (int8x16_t a, int8x16_t b, mve_pred16_t p)
   return vhsubq_x (a, b, p);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_u16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_u16.c
index d700741..86fc9d7 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_u16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_u16.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -38,4 +42,8 @@ foo1 (uint16x8_t a, uint16x8_t b, mve_pred16_t p)
   return vhsubq_x (a, b, p);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_u32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_u32.c
index f43c962..5327426 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_u32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_u32.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -38,4 +42,8 @@ foo1 (uint32x4_t a, uint32x4_t b, mve_pred16_t p)
   return vhsubq_x (a, b, p);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_u8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_u8.c
index a0908ba..04d89c6 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_u8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vhsubq_x_u8.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -38,4 +42,8 @@ foo1 (uint8x16_t a, uint8x16_t b, mve_pred16_t p)
   return vhsubq_x (a, b, p);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vld2q_f16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vld2q_f16.c
index 24e7a2e..81690b1 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vld2q_f16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vld2q_f16.c
@@ -1,22 +1,45 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vld20.16	{q[0-9]+, q[0-9]+}, \[(?:ip|fp|r[0-9]+)\](?:	@.*|)
+**	...
+**	vld21.16	{q[0-9]+, q[0-9]+}, \[(?:ip|fp|r[0-9]+)\](?:	@.*|)
+**	...
+*/
 float16x8x2_t
-foo (float16_t const * addr)
+foo (float16_t const *addr)
 {
   return vld2q_f16 (addr);
 }
 
-/* { dg-final { scan-assembler "vld20.16"  }  } */
-/* { dg-final { scan-assembler "vld21.16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vld20.16	{q[0-9]+, q[0-9]+}, \[(?:ip|fp|r[0-9]+)\](?:	@.*|)
+**	...
+**	vld21.16	{q[0-9]+, q[0-9]+}, \[(?:ip|fp|r[0-9]+)\](?:	@.*|)
+**	...
+*/
 float16x8x2_t
-foo1 (float16_t const * addr)
+foo1 (float16_t const *addr)
 {
   return vld2q (addr);
 }
 
-/* { dg-final { scan-assembler "vld20.16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vld2q_f32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vld2q_f32.c
index 727484c..d2ae31f 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vld2q_f32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vld2q_f32.c
@@ -1,22 +1,45 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vld20.32	{q[0-9]+, q[0-9]+}, \[(?:ip|fp|r[0-9]+)\](?:	@.*|)
+**	...
+**	vld21.32	{q[0-9]+, q[0-9]+}, \[(?:ip|fp|r[0-9]+)\](?:	@.*|)
+**	...
+*/
 float32x4x2_t
-foo (float32_t const * addr)
+foo (float32_t const *addr)
 {
   return vld2q_f32 (addr);
 }
 
-/* { dg-final { scan-assembler "vld20.32"  }  } */
-/* { dg-final { scan-assembler "vld21.32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vld20.32	{q[0-9]+, q[0-9]+}, \[(?:ip|fp|r[0-9]+)\](?:	@.*|)
+**	...
+**	vld21.32	{q[0-9]+, q[0-9]+}, \[(?:ip|fp|r[0-9]+)\](?:	@.*|)
+**	...
+*/
 float32x4x2_t
-foo1 (float32_t const * addr)
+foo1 (float32_t const *addr)
 {
   return vld2q (addr);
 }
 
-/* { dg-final { scan-assembler "vld20.32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vld2q_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vld2q_s16.c
index f2864a0..fb4dc1b 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vld2q_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vld2q_s16.c
@@ -1,22 +1,45 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vld20.16	{q[0-9]+, q[0-9]+}, \[(?:ip|fp|r[0-9]+)\](?:	@.*|)
+**	...
+**	vld21.16	{q[0-9]+, q[0-9]+}, \[(?:ip|fp|r[0-9]+)\](?:	@.*|)
+**	...
+*/
 int16x8x2_t
-foo (int16_t const * addr)
+foo (int16_t const *addr)
 {
   return vld2q_s16 (addr);
 }
 
-/* { dg-final { scan-assembler "vld20.16"  }  } */
-/* { dg-final { scan-assembler "vld21.16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vld20.16	{q[0-9]+, q[0-9]+}, \[(?:ip|fp|r[0-9]+)\](?:	@.*|)
+**	...
+**	vld21.16	{q[0-9]+, q[0-9]+}, \[(?:ip|fp|r[0-9]+)\](?:	@.*|)
+**	...
+*/
 int16x8x2_t
-foo1 (int16_t const * addr)
+foo1 (int16_t const *addr)
 {
   return vld2q (addr);
 }
 
-/* { dg-final { scan-assembler "vld20.16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vld2q_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vld2q_s32.c
index 9fe2e04..aeb8523 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vld2q_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vld2q_s32.c
@@ -1,22 +1,45 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vld20.32	{q[0-9]+, q[0-9]+}, \[(?:ip|fp|r[0-9]+)\](?:	@.*|)
+**	...
+**	vld21.32	{q[0-9]+, q[0-9]+}, \[(?:ip|fp|r[0-9]+)\](?:	@.*|)
+**	...
+*/
 int32x4x2_t
-foo (int32_t const * addr)
+foo (int32_t const *addr)
 {
   return vld2q_s32 (addr);
 }
 
-/* { dg-final { scan-assembler "vld20.32"  }  } */
-/* { dg-final { scan-assembler "vld21.32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vld20.32	{q[0-9]+, q[0-9]+}, \[(?:ip|fp|r[0-9]+)\](?:	@.*|)
+**	...
+**	vld21.32	{q[0-9]+, q[0-9]+}, \[(?:ip|fp|r[0-9]+)\](?:	@.*|)
+**	...
+*/
 int32x4x2_t
-foo1 (int32_t const * addr)
+foo1 (int32_t const *addr)
 {
   return vld2q (addr);
 }
 
-/* { dg-final { scan-assembler "vld20.32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vld2q_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vld2q_s8.c
index 736080a..687e5de 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vld2q_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vld2q_s8.c
@@ -1,22 +1,45 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vld20.8	{q[0-9]+, q[0-9]+}, \[(?:ip|fp|r[0-9]+)\](?:	@.*|)
+**	...
+**	vld21.8	{q[0-9]+, q[0-9]+}, \[(?:ip|fp|r[0-9]+)\](?:	@.*|)
+**	...
+*/
 int8x16x2_t
-foo (int8_t const * addr)
+foo (int8_t const *addr)
 {
   return vld2q_s8 (addr);
 }
 
-/* { dg-final { scan-assembler "vld20.8"  }  } */
-/* { dg-final { scan-assembler "vld21.8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vld20.8	{q[0-9]+, q[0-9]+}, \[(?:ip|fp|r[0-9]+)\](?:	@.*|)
+**	...
+**	vld21.8	{q[0-9]+, q[0-9]+}, \[(?:ip|fp|r[0-9]+)\](?:	@.*|)
+**	...
+*/
 int8x16x2_t
-foo1 (int8_t const * addr)
+foo1 (int8_t const *addr)
 {
   return vld2q (addr);
 }
 
-/* { dg-final { scan-assembler "vld20.8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vld2q_u16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vld2q_u16.c
index 2d89ebd..281fe5e 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vld2q_u16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vld2q_u16.c
@@ -1,22 +1,45 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vld20.16	{q[0-9]+, q[0-9]+}, \[(?:ip|fp|r[0-9]+)\](?:	@.*|)
+**	...
+**	vld21.16	{q[0-9]+, q[0-9]+}, \[(?:ip|fp|r[0-9]+)\](?:	@.*|)
+**	...
+*/
 uint16x8x2_t
-foo (uint16_t const * addr)
+foo (uint16_t const *addr)
 {
   return vld2q_u16 (addr);
 }
 
-/* { dg-final { scan-assembler "vld20.16"  }  } */
-/* { dg-final { scan-assembler "vld21.16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vld20.16	{q[0-9]+, q[0-9]+}, \[(?:ip|fp|r[0-9]+)\](?:	@.*|)
+**	...
+**	vld21.16	{q[0-9]+, q[0-9]+}, \[(?:ip|fp|r[0-9]+)\](?:	@.*|)
+**	...
+*/
 uint16x8x2_t
-foo1 (uint16_t const * addr)
+foo1 (uint16_t const *addr)
 {
   return vld2q (addr);
 }
 
-/* { dg-final { scan-assembler "vld20.16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vld2q_u32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vld2q_u32.c
index 28d311e..524afee 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vld2q_u32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vld2q_u32.c
@@ -1,22 +1,45 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vld20.32	{q[0-9]+, q[0-9]+}, \[(?:ip|fp|r[0-9]+)\](?:	@.*|)
+**	...
+**	vld21.32	{q[0-9]+, q[0-9]+}, \[(?:ip|fp|r[0-9]+)\](?:	@.*|)
+**	...
+*/
 uint32x4x2_t
-foo (uint32_t const * addr)
+foo (uint32_t const *addr)
 {
   return vld2q_u32 (addr);
 }
 
-/* { dg-final { scan-assembler "vld20.32"  }  } */
-/* { dg-final { scan-assembler "vld21.32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vld20.32	{q[0-9]+, q[0-9]+}, \[(?:ip|fp|r[0-9]+)\](?:	@.*|)
+**	...
+**	vld21.32	{q[0-9]+, q[0-9]+}, \[(?:ip|fp|r[0-9]+)\](?:	@.*|)
+**	...
+*/
 uint32x4x2_t
-foo1 (uint32_t const * addr)
+foo1 (uint32_t const *addr)
 {
   return vld2q (addr);
 }
 
-/* { dg-final { scan-assembler "vld20.32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vld2q_u8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vld2q_u8.c
index 790c974..9eebbd4 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vld2q_u8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vld2q_u8.c
@@ -1,22 +1,45 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vld20.8	{q[0-9]+, q[0-9]+}, \[(?:ip|fp|r[0-9]+)\](?:	@.*|)
+**	...
+**	vld21.8	{q[0-9]+, q[0-9]+}, \[(?:ip|fp|r[0-9]+)\](?:	@.*|)
+**	...
+*/
 uint8x16x2_t
-foo (uint8_t const * addr)
+foo (uint8_t const *addr)
 {
   return vld2q_u8 (addr);
 }
 
-/* { dg-final { scan-assembler "vld20.8"  }  } */
-/* { dg-final { scan-assembler "vld21.8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vld20.8	{q[0-9]+, q[0-9]+}, \[(?:ip|fp|r[0-9]+)\](?:	@.*|)
+**	...
+**	vld21.8	{q[0-9]+, q[0-9]+}, \[(?:ip|fp|r[0-9]+)\](?:	@.*|)
+**	...
+*/
 uint8x16x2_t
-foo1 (uint8_t const * addr)
+foo1 (uint8_t const *addr)
 {
   return vld2q (addr);
 }
 
-/* { dg-final { scan-assembler "vld20.8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmladavaxq_p_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmladavaxq_p_s16.c
index f201d5f..5925d9e 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmladavaxq_p_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmladavaxq_p_s16.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -38,4 +42,8 @@ foo1 (int32_t add, int16x8_t m1, int16x8_t m2, mve_pred16_t p)
   return vmladavaxq_p (add, m1, m2, p);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmladavaxq_p_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmladavaxq_p_s32.c
index c90647a..87d66e6 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmladavaxq_p_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmladavaxq_p_s32.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -38,4 +42,8 @@ foo1 (int32_t add, int32x4_t m1, int32x4_t m2, mve_pred16_t p)
   return vmladavaxq_p (add, m1, m2, p);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmladavaxq_p_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmladavaxq_p_s8.c
index 57af7bc..803a5be 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmladavaxq_p_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmladavaxq_p_s8.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -38,4 +42,8 @@ foo1 (int32_t add, int8x16_t m1, int8x16_t m2, mve_pred16_t p)
   return vmladavaxq_p (add, m1, m2, p);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmladavaxq_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmladavaxq_s16.c
index 684580d..6a81b4a 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmladavaxq_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmladavaxq_s16.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (int32_t add, int16x8_t m1, int16x8_t m2)
   return vmladavaxq (add, m1, m2);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmladavaxq_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmladavaxq_s32.c
index 5d15264..b63ca43 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmladavaxq_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmladavaxq_s32.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (int32_t add, int32x4_t m1, int32x4_t m2)
   return vmladavaxq (add, m1, m2);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmladavaxq_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmladavaxq_s8.c
index 71bcdc9..2430858 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmladavaxq_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmladavaxq_s8.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (int32_t add, int8x16_t m1, int8x16_t m2)
   return vmladavaxq (add, m1, m2);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_m_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_m_s16.c
index 4971869..a7d8460 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_m_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_m_s16.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulht.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t inactive, int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vmulhq_m_s16 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulht.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulht.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t inactive, int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vmulhq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulht.s16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_m_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_m_s32.c
index 3006de7..997fdbe 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_m_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_m_s32.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulht.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t inactive, int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vmulhq_m_s32 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulht.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulht.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t inactive, int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vmulhq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulht.s32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_m_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_m_s8.c
index fbcef24..567461f 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_m_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_m_s8.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulht.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t inactive, int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vmulhq_m_s8 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulht.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulht.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t inactive, int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vmulhq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulht.s8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_m_u16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_m_u16.c
index 7059fec..9b81382 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_m_u16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_m_u16.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulht.u16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo (uint16x8_t inactive, uint16x8_t a, uint16x8_t b, mve_pred16_t p)
 {
   return vmulhq_m_u16 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulht.u16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulht.u16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo1 (uint16x8_t inactive, uint16x8_t a, uint16x8_t b, mve_pred16_t p)
 {
   return vmulhq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulht.u16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_m_u32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_m_u32.c
index 1c2de708..248432a 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_m_u32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_m_u32.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulht.u32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo (uint32x4_t inactive, uint32x4_t a, uint32x4_t b, mve_pred16_t p)
 {
   return vmulhq_m_u32 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulht.u32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulht.u32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo1 (uint32x4_t inactive, uint32x4_t a, uint32x4_t b, mve_pred16_t p)
 {
   return vmulhq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulht.u32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_m_u8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_m_u8.c
index 5eed85f..464180c 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_m_u8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_m_u8.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulht.u8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint8x16_t
 foo (uint8x16_t inactive, uint8x16_t a, uint8x16_t b, mve_pred16_t p)
 {
   return vmulhq_m_u8 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulht.u8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulht.u8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint8x16_t
 foo1 (uint8x16_t inactive, uint8x16_t a, uint8x16_t b, mve_pred16_t p)
 {
   return vmulhq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulht.u8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_s16.c
index a7260df..0950c06 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_s16.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmulh.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t a, int16x8_t b)
 {
   return vmulhq_s16 (a, b);
 }
 
-/* { dg-final { scan-assembler "vmulh.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmulh.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t a, int16x8_t b)
 {
   return vmulhq (a, b);
 }
 
-/* { dg-final { scan-assembler "vmulh.s16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_s32.c
index 4fe46e6..db2ab42 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_s32.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmulh.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t a, int32x4_t b)
 {
   return vmulhq_s32 (a, b);
 }
 
-/* { dg-final { scan-assembler "vmulh.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmulh.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t a, int32x4_t b)
 {
   return vmulhq (a, b);
 }
 
-/* { dg-final { scan-assembler "vmulh.s32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_s8.c
index acc0803..8bb2239 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_s8.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmulh.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t a, int8x16_t b)
 {
   return vmulhq_s8 (a, b);
 }
 
-/* { dg-final { scan-assembler "vmulh.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmulh.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t a, int8x16_t b)
 {
   return vmulhq (a, b);
 }
 
-/* { dg-final { scan-assembler "vmulh.s8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_u16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_u16.c
index 37e40f0..bb88136 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_u16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_u16.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmulh.u16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo (uint16x8_t a, uint16x8_t b)
 {
   return vmulhq_u16 (a, b);
 }
 
-/* { dg-final { scan-assembler "vmulh.u16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmulh.u16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo1 (uint16x8_t a, uint16x8_t b)
 {
   return vmulhq (a, b);
 }
 
-/* { dg-final { scan-assembler "vmulh.u16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_u32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_u32.c
index 5673d91..d42c41a 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_u32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_u32.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmulh.u32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo (uint32x4_t a, uint32x4_t b)
 {
   return vmulhq_u32 (a, b);
 }
 
-/* { dg-final { scan-assembler "vmulh.u32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmulh.u32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo1 (uint32x4_t a, uint32x4_t b)
 {
   return vmulhq (a, b);
 }
 
-/* { dg-final { scan-assembler "vmulh.u32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_u8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_u8.c
index 29c6312..c666a96 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_u8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_u8.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmulh.u8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint8x16_t
 foo (uint8x16_t a, uint8x16_t b)
 {
   return vmulhq_u8 (a, b);
 }
 
-/* { dg-final { scan-assembler "vmulh.u8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmulh.u8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint8x16_t
 foo1 (uint8x16_t a, uint8x16_t b)
 {
   return vmulhq (a, b);
 }
 
-/* { dg-final { scan-assembler "vmulh.u8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_x_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_x_s16.c
index b783570..a323c96 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_x_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_x_s16.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulht.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vmulhq_x_s16 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulht.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulht.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vmulhq_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_x_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_x_s32.c
index 003485b..98168b1 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_x_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_x_s32.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulht.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vmulhq_x_s32 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulht.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulht.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vmulhq_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_x_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_x_s8.c
index d2359cd..b50f59b 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_x_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_x_s8.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulht.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vmulhq_x_s8 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulht.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulht.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vmulhq_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_x_u16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_x_u16.c
index c052c4a..afa803c 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_x_u16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_x_u16.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulht.u16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo (uint16x8_t a, uint16x8_t b, mve_pred16_t p)
 {
   return vmulhq_x_u16 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulht.u16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulht.u16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo1 (uint16x8_t a, uint16x8_t b, mve_pred16_t p)
 {
   return vmulhq_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_x_u32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_x_u32.c
index 7eeba8b..22179547 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_x_u32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_x_u32.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulht.u32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo (uint32x4_t a, uint32x4_t b, mve_pred16_t p)
 {
   return vmulhq_x_u32 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulht.u32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulht.u32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo1 (uint32x4_t a, uint32x4_t b, mve_pred16_t p)
 {
   return vmulhq_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_x_u8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_x_u8.c
index ff2a53f..4383e2e 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_x_u8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulhq_x_u8.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulht.u8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint8x16_t
 foo (uint8x16_t a, uint8x16_t b, mve_pred16_t p)
 {
   return vmulhq_x_u8 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulht.u8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulht.u8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint8x16_t
 foo1 (uint8x16_t a, uint8x16_t b, mve_pred16_t p)
 {
   return vmulhq_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_m_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_m_s16.c
index be93327..a4cc5e5 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_m_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_m_s16.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmullbt.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t inactive, int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vmullbq_int_m_s16 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmullbt.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmullbt.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t inactive, int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vmullbq_int_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmullbt.s16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_m_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_m_s32.c
index 3dfc267..a195884 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_m_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_m_s32.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmullbt.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int64x2_t
 foo (int64x2_t inactive, int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vmullbq_int_m_s32 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmullbt.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmullbt.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int64x2_t
 foo1 (int64x2_t inactive, int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vmullbq_int_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmullbt.s32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_m_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_m_s8.c
index f8c449b..3a5d770 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_m_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_m_s8.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmullbt.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t inactive, int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vmullbq_int_m_s8 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmullbt.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmullbt.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t inactive, int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vmullbq_int_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmullbt.s8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_m_u16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_m_u16.c
index dd6ed6b..5e327d2 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_m_u16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_m_u16.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmullbt.u16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo (uint32x4_t inactive, uint16x8_t a, uint16x8_t b, mve_pred16_t p)
 {
   return vmullbq_int_m_u16 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmullbt.u16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmullbt.u16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo1 (uint32x4_t inactive, uint16x8_t a, uint16x8_t b, mve_pred16_t p)
 {
   return vmullbq_int_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmullbt.u16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_m_u32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_m_u32.c
index 85ce75e..fb2de99 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_m_u32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_m_u32.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmullbt.u32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint64x2_t
 foo (uint64x2_t inactive, uint32x4_t a, uint32x4_t b, mve_pred16_t p)
 {
   return vmullbq_int_m_u32 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmullbt.u32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmullbt.u32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint64x2_t
 foo1 (uint64x2_t inactive, uint32x4_t a, uint32x4_t b, mve_pred16_t p)
 {
   return vmullbq_int_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmullbt.u32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_m_u8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_m_u8.c
index d131a5d..4cc06c4 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_m_u8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_m_u8.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmullbt.u8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo (uint16x8_t inactive, uint8x16_t a, uint8x16_t b, mve_pred16_t p)
 {
   return vmullbq_int_m_u8 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmullbt.u8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmullbt.u8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo1 (uint16x8_t inactive, uint8x16_t a, uint8x16_t b, mve_pred16_t p)
 {
   return vmullbq_int_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmullbt.u8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_s16.c
index 22f4d27..16c0982 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_s16.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmullb.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int16x8_t a, int16x8_t b)
 {
   return vmullbq_int_s16 (a, b);
 }
 
-/* { dg-final { scan-assembler "vmullb.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmullb.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int16x8_t a, int16x8_t b)
 {
   return vmullbq_int (a, b);
 }
 
-/* { dg-final { scan-assembler "vmullb.s16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_s32.c
index 6e677f2..e0a82d6 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_s32.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmullb.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int64x2_t
 foo (int32x4_t a, int32x4_t b)
 {
   return vmullbq_int_s32 (a, b);
 }
 
-/* { dg-final { scan-assembler "vmullb.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmullb.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int64x2_t
 foo1 (int32x4_t a, int32x4_t b)
 {
   return vmullbq_int (a, b);
 }
 
-/* { dg-final { scan-assembler "vmullb.s32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_s8.c
index f40b8a6..031a433 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_s8.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmullb.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int8x16_t a, int8x16_t b)
 {
   return vmullbq_int_s8 (a, b);
 }
 
-/* { dg-final { scan-assembler "vmullb.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmullb.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int8x16_t a, int8x16_t b)
 {
   return vmullbq_int (a, b);
 }
 
-/* { dg-final { scan-assembler "vmullb.s8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_u16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_u16.c
index 3529ab2..4bb19bf 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_u16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_u16.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmullb.u16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo (uint16x8_t a, uint16x8_t b)
 {
   return vmullbq_int_u16 (a, b);
 }
 
-/* { dg-final { scan-assembler "vmullb.u16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmullb.u16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo1 (uint16x8_t a, uint16x8_t b)
 {
   return vmullbq_int (a, b);
 }
 
-/* { dg-final { scan-assembler "vmullb.u16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_u32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_u32.c
index d843d2bf..d461ed9 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_u32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_u32.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmullb.u32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint64x2_t
 foo (uint32x4_t a, uint32x4_t b)
 {
   return vmullbq_int_u32 (a, b);
 }
 
-/* { dg-final { scan-assembler "vmullb.u32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmullb.u32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint64x2_t
 foo1 (uint32x4_t a, uint32x4_t b)
 {
   return vmullbq_int (a, b);
 }
 
-/* { dg-final { scan-assembler "vmullb.u32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_u8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_u8.c
index 6268c46..c079077 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_u8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_u8.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmullb.u8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo (uint8x16_t a, uint8x16_t b)
 {
   return vmullbq_int_u8 (a, b);
 }
 
-/* { dg-final { scan-assembler "vmullb.u8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmullb.u8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo1 (uint8x16_t a, uint8x16_t b)
 {
   return vmullbq_int (a, b);
 }
 
-/* { dg-final { scan-assembler "vmullb.u8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_x_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_x_s16.c
index 87f8e21..ee83ca6 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_x_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_x_s16.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmullbt.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vmullbq_int_x_s16 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmullbt.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmullbt.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vmullbq_int_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_x_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_x_s32.c
index 5e56372..42ae332 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_x_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_x_s32.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmullbt.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int64x2_t
 foo (int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vmullbq_int_x_s32 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmullbt.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmullbt.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int64x2_t
 foo1 (int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vmullbq_int_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_x_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_x_s8.c
index b2ca413..8dcf9b7 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_x_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_x_s8.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmullbt.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vmullbq_int_x_s8 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmullbt.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmullbt.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vmullbq_int_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_x_u16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_x_u16.c
index 1526910..31330da 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_x_u16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_x_u16.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmullbt.u16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo (uint16x8_t a, uint16x8_t b, mve_pred16_t p)
 {
   return vmullbq_int_x_u16 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmullbt.u16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmullbt.u16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo1 (uint16x8_t a, uint16x8_t b, mve_pred16_t p)
 {
   return vmullbq_int_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_x_u32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_x_u32.c
index 7a78363..b882d64 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_x_u32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_x_u32.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmullbt.u32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint64x2_t
 foo (uint32x4_t a, uint32x4_t b, mve_pred16_t p)
 {
   return vmullbq_int_x_u32 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmullbt.u32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmullbt.u32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint64x2_t
 foo1 (uint32x4_t a, uint32x4_t b, mve_pred16_t p)
 {
   return vmullbq_int_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_x_u8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_x_u8.c
index f422a3c..4b40237 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_x_u8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_int_x_u8.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmullbt.u8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo (uint8x16_t a, uint8x16_t b, mve_pred16_t p)
 {
   return vmullbq_int_x_u8 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmullbt.u8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmullbt.u8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo1 (uint8x16_t a, uint8x16_t b, mve_pred16_t p)
 {
   return vmullbq_int_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_poly_m_p16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_poly_m_p16.c
index 527acb7..2efb87d 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_poly_m_p16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_poly_m_p16.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmullbt.p16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo (uint32x4_t inactive, uint16x8_t a, uint16x8_t b, mve_pred16_t p)
 {
   return vmullbq_poly_m_p16 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmullbt.p16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmullbt.p16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo1 (uint32x4_t inactive, uint16x8_t a, uint16x8_t b, mve_pred16_t p)
 {
   return vmullbq_poly_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmullbt.p16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_poly_m_p8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_poly_m_p8.c
index 5403394..b435f44 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_poly_m_p8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_poly_m_p8.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmullbt.p8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo (uint16x8_t inactive, uint8x16_t a, uint8x16_t b, mve_pred16_t p)
 {
   return vmullbq_poly_m_p8 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmullbt.p8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmullbt.p8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo1 (uint16x8_t inactive, uint8x16_t a, uint8x16_t b, mve_pred16_t p)
 {
   return vmullbq_poly_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmullbt.p8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_poly_p16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_poly_p16.c
index d01d599..bfd0522 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_poly_p16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_poly_p16.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmullb.p16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo (uint16x8_t a, uint16x8_t b)
 {
   return vmullbq_poly_p16 (a, b);
 }
 
-/* { dg-final { scan-assembler "vmullb.p16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmullb.p16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo1 (uint16x8_t a, uint16x8_t b)
 {
   return vmullbq_poly (a, b);
 }
 
-/* { dg-final { scan-assembler "vmullb.p16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_poly_p8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_poly_p8.c
index de97134..a2a53e8 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_poly_p8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_poly_p8.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmullb.p8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo (uint8x16_t a, uint8x16_t b)
 {
   return vmullbq_poly_p8 (a, b);
 }
 
-/* { dg-final { scan-assembler "vmullb.p8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmullb.p8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo1 (uint8x16_t a, uint8x16_t b)
 {
   return vmullbq_poly (a, b);
 }
 
-/* { dg-final { scan-assembler "vmullb.p8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_poly_x_p16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_poly_x_p16.c
index f94d905..bee45f9 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_poly_x_p16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_poly_x_p16.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmullbt.p16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo (uint16x8_t a, uint16x8_t b, mve_pred16_t p)
 {
   return vmullbq_poly_x_p16 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmullbt.p16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmullbt.p16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo1 (uint16x8_t a, uint16x8_t b, mve_pred16_t p)
 {
   return vmullbq_poly_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_poly_x_p8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_poly_x_p8.c
index 6fdc944..7cd15f3a 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_poly_x_p8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmullbq_poly_x_p8.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmullbt.p8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo (uint8x16_t a, uint8x16_t b, mve_pred16_t p)
 {
   return vmullbq_poly_x_p8 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmullbt.p8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmullbt.p8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo1 (uint8x16_t a, uint8x16_t b, mve_pred16_t p)
 {
   return vmullbq_poly_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_m_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_m_s16.c
index 25ecf7a..7f573e9 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_m_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_m_s16.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulltt.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t inactive, int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vmulltq_int_m_s16 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulltt.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulltt.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t inactive, int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vmulltq_int_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulltt.s16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_m_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_m_s32.c
index f8d0288..da440dd 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_m_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_m_s32.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulltt.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int64x2_t
 foo (int64x2_t inactive, int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vmulltq_int_m_s32 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulltt.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulltt.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int64x2_t
 foo1 (int64x2_t inactive, int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vmulltq_int_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulltt.s32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_m_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_m_s8.c
index 3f2fc33..ceb8e1d 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_m_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_m_s8.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulltt.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t inactive, int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vmulltq_int_m_s8 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulltt.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulltt.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t inactive, int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vmulltq_int_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulltt.s8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_m_u16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_m_u16.c
index b7ab408..a751546 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_m_u16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_m_u16.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulltt.u16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo (uint32x4_t inactive, uint16x8_t a, uint16x8_t b, mve_pred16_t p)
 {
   return vmulltq_int_m_u16 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulltt.u16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulltt.u16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo1 (uint32x4_t inactive, uint16x8_t a, uint16x8_t b, mve_pred16_t p)
 {
   return vmulltq_int_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulltt.u16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_m_u32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_m_u32.c
index e43ad98..a6c4d27 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_m_u32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_m_u32.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulltt.u32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint64x2_t
 foo (uint64x2_t inactive, uint32x4_t a, uint32x4_t b, mve_pred16_t p)
 {
   return vmulltq_int_m_u32 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulltt.u32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulltt.u32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint64x2_t
 foo1 (uint64x2_t inactive, uint32x4_t a, uint32x4_t b, mve_pred16_t p)
 {
   return vmulltq_int_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulltt.u32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_m_u8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_m_u8.c
index 7f4b90b..1a7466b 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_m_u8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_m_u8.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulltt.u8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo (uint16x8_t inactive, uint8x16_t a, uint8x16_t b, mve_pred16_t p)
 {
   return vmulltq_int_m_u8 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulltt.u8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulltt.u8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo1 (uint16x8_t inactive, uint8x16_t a, uint8x16_t b, mve_pred16_t p)
 {
   return vmulltq_int_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulltt.u8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_s16.c
index 34b75d4..cd907f6 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_s16.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmullt.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int16x8_t a, int16x8_t b)
 {
   return vmulltq_int_s16 (a, b);
 }
 
-/* { dg-final { scan-assembler "vmullt.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmullt.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int16x8_t a, int16x8_t b)
 {
   return vmulltq_int (a, b);
 }
 
-/* { dg-final { scan-assembler "vmullt.s16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_s32.c
index 7e09bf9..dbc4c80 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_s32.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmullt.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int64x2_t
 foo (int32x4_t a, int32x4_t b)
 {
   return vmulltq_int_s32 (a, b);
 }
 
-/* { dg-final { scan-assembler "vmullt.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmullt.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int64x2_t
 foo1 (int32x4_t a, int32x4_t b)
 {
   return vmulltq_int (a, b);
 }
 
-/* { dg-final { scan-assembler "vmullt.s32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_s8.c
index b6eb1f5..0fef6a2 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_s8.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmullt.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int8x16_t a, int8x16_t b)
 {
   return vmulltq_int_s8 (a, b);
 }
 
-/* { dg-final { scan-assembler "vmullt.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmullt.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int8x16_t a, int8x16_t b)
 {
   return vmulltq_int (a, b);
 }
 
-/* { dg-final { scan-assembler "vmullt.s8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_u16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_u16.c
index f4fc9c0..91b6fb4 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_u16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_u16.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmullt.u16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo (uint16x8_t a, uint16x8_t b)
 {
   return vmulltq_int_u16 (a, b);
 }
 
-/* { dg-final { scan-assembler "vmullt.u16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmullt.u16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo1 (uint16x8_t a, uint16x8_t b)
 {
   return vmulltq_int (a, b);
 }
 
-/* { dg-final { scan-assembler "vmullt.u16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_u32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_u32.c
index d1bc3a8..71c62a1 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_u32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_u32.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmullt.u32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint64x2_t
 foo (uint32x4_t a, uint32x4_t b)
 {
   return vmulltq_int_u32 (a, b);
 }
 
-/* { dg-final { scan-assembler "vmullt.u32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmullt.u32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint64x2_t
 foo1 (uint32x4_t a, uint32x4_t b)
 {
   return vmulltq_int (a, b);
 }
 
-/* { dg-final { scan-assembler "vmullt.u32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_u8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_u8.c
index 87f3c4e..7506adc 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_u8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_u8.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmullt.u8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo (uint8x16_t a, uint8x16_t b)
 {
   return vmulltq_int_u8 (a, b);
 }
 
-/* { dg-final { scan-assembler "vmullt.u8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmullt.u8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo1 (uint8x16_t a, uint8x16_t b)
 {
   return vmulltq_int (a, b);
 }
 
-/* { dg-final { scan-assembler "vmullt.u8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_x_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_x_s16.c
index c13ef50..c2376ab 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_x_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_x_s16.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulltt.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vmulltq_int_x_s16 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulltt.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulltt.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vmulltq_int_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_x_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_x_s32.c
index e82321e..788789d 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_x_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_x_s32.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulltt.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int64x2_t
 foo (int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vmulltq_int_x_s32 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulltt.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulltt.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int64x2_t
 foo1 (int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vmulltq_int_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_x_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_x_s8.c
index 7f093c2..3935741 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_x_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_x_s8.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulltt.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vmulltq_int_x_s8 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulltt.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulltt.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vmulltq_int_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_x_u16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_x_u16.c
index d0f6461..32ee5b2 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_x_u16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_x_u16.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulltt.u16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo (uint16x8_t a, uint16x8_t b, mve_pred16_t p)
 {
   return vmulltq_int_x_u16 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulltt.u16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulltt.u16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo1 (uint16x8_t a, uint16x8_t b, mve_pred16_t p)
 {
   return vmulltq_int_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_x_u32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_x_u32.c
index 55e19cb..cc31056 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_x_u32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_x_u32.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulltt.u32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint64x2_t
 foo (uint32x4_t a, uint32x4_t b, mve_pred16_t p)
 {
   return vmulltq_int_x_u32 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulltt.u32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulltt.u32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint64x2_t
 foo1 (uint32x4_t a, uint32x4_t b, mve_pred16_t p)
 {
   return vmulltq_int_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_x_u8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_x_u8.c
index 650c947..01713fb 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_x_u8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_int_x_u8.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulltt.u8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo (uint8x16_t a, uint8x16_t b, mve_pred16_t p)
 {
   return vmulltq_int_x_u8 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulltt.u8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulltt.u8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo1 (uint8x16_t a, uint8x16_t b, mve_pred16_t p)
 {
   return vmulltq_int_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_poly_m_p16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_poly_m_p16.c
index 944db4c..6d368e2 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_poly_m_p16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_poly_m_p16.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulltt.p16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo (uint32x4_t inactive, uint16x8_t a, uint16x8_t b, mve_pred16_t p)
 {
   return vmulltq_poly_m_p16 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulltt.p16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulltt.p16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo1 (uint32x4_t inactive, uint16x8_t a, uint16x8_t b, mve_pred16_t p)
 {
   return vmulltq_poly_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulltt.p16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_poly_m_p8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_poly_m_p8.c
index d073119..75b8811 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_poly_m_p8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_poly_m_p8.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulltt.p8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo (uint16x8_t inactive, uint8x16_t a, uint8x16_t b, mve_pred16_t p)
 {
   return vmulltq_poly_m_p8 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulltt.p8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulltt.p8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo1 (uint16x8_t inactive, uint8x16_t a, uint8x16_t b, mve_pred16_t p)
 {
   return vmulltq_poly_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulltt.p8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_poly_p16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_poly_p16.c
index 121de8e..9f08d57 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_poly_p16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_poly_p16.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmullt.p16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo (uint16x8_t a, uint16x8_t b)
 {
   return vmulltq_poly_p16 (a, b);
 }
 
-/* { dg-final { scan-assembler "vmullt.p16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmullt.p16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo1 (uint16x8_t a, uint16x8_t b)
 {
   return vmulltq_poly (a, b);
 }
 
-/* { dg-final { scan-assembler "vmullt.p16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_poly_p8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_poly_p8.c
index c7d9548..59e6e1b 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_poly_p8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_poly_p8.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmullt.p8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo (uint8x16_t a, uint8x16_t b)
 {
   return vmulltq_poly_p8 (a, b);
 }
 
-/* { dg-final { scan-assembler "vmullt.p8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmullt.p8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo1 (uint8x16_t a, uint8x16_t b)
 {
   return vmulltq_poly (a, b);
 }
 
-/* { dg-final { scan-assembler "vmullt.p8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_poly_x_p16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_poly_x_p16.c
index fb4b849..f3d3de2 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_poly_x_p16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_poly_x_p16.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulltt.p16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo (uint16x8_t a, uint16x8_t b, mve_pred16_t p)
 {
   return vmulltq_poly_x_p16 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulltt.p16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulltt.p16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint32x4_t
 foo1 (uint16x8_t a, uint16x8_t b, mve_pred16_t p)
 {
   return vmulltq_poly_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_poly_x_p8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_poly_x_p8.c
index 1e79b29..2c7a629 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_poly_x_p8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vmulltq_poly_x_p8.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulltt.p8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo (uint8x16_t a, uint8x16_t b, mve_pred16_t p)
 {
   return vmulltq_poly_x_p8 (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vmulltt.p8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vmulltt.p8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 uint16x8_t
 foo1 (uint8x16_t a, uint8x16_t b, mve_pred16_t p)
 {
   return vmulltq_poly_x (a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_f16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_f16.c
index 9572c14..9853cf6 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_f16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_f16.c
@@ -1,13 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vneg.f16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo (float16x8_t a)
 {
   return vnegq_f16 (a);
 }
 
-/* { dg-final { scan-assembler "vneg.f16"  }  } */
+
+/*
+**foo1:
+**	...
+**	vneg.f16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
+float16x8_t
+foo1 (float16x8_t a)
+{
+  return vnegq (a);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_f32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_f32.c
index be73cc0..489cfc7 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_f32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_f32.c
@@ -1,13 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vneg.f32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo (float32x4_t a)
 {
   return vnegq_f32 (a);
 }
 
-/* { dg-final { scan-assembler "vneg.f32"  }  } */
+
+/*
+**foo1:
+**	...
+**	vneg.f32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
+float32x4_t
+foo1 (float32x4_t a)
+{
+  return vnegq (a);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_m_f16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_m_f16.c
index 0d917b8..c8b307e 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_m_f16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_m_f16.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vnegt.f16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo (float16x8_t inactive, float16x8_t a, mve_pred16_t p)
 {
   return vnegq_m_f16 (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vnegt.f16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vnegt.f16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo1 (float16x8_t inactive, float16x8_t a, mve_pred16_t p)
 {
   return vnegq_m (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_m_f32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_m_f32.c
index f1c0e9a..a530a05 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_m_f32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_m_f32.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vnegt.f32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo (float32x4_t inactive, float32x4_t a, mve_pred16_t p)
 {
   return vnegq_m_f32 (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vnegt.f32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vnegt.f32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo1 (float32x4_t inactive, float32x4_t a, mve_pred16_t p)
 {
   return vnegq_m (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_m_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_m_s16.c
index 9a945ee..46d6e79 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_m_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_m_s16.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vnegt.s16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t inactive, int16x8_t a, mve_pred16_t p)
 {
   return vnegq_m_s16 (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vnegt.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vnegt.s16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t inactive, int16x8_t a, mve_pred16_t p)
 {
   return vnegq_m (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_m_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_m_s32.c
index 811f1df..5fb1f5c 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_m_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_m_s32.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vnegt.s32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t inactive, int32x4_t a, mve_pred16_t p)
 {
   return vnegq_m_s32 (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vnegt.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vnegt.s32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t inactive, int32x4_t a, mve_pred16_t p)
 {
   return vnegq_m (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_m_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_m_s8.c
index 430ebc7..868a968 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_m_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_m_s8.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vnegt.s8	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t inactive, int8x16_t a, mve_pred16_t p)
 {
   return vnegq_m_s8 (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vnegt.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vnegt.s8	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t inactive, int8x16_t a, mve_pred16_t p)
 {
   return vnegq_m (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_s16.c
index a47f9b3..3b518c8 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_s16.c
@@ -1,21 +1,41 @@
-/* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
-/* { dg-add-options arm_v8_1m_mve_fp } */
+/* { dg-require-effective-target arm_v8_1m_mve_ok } */
+/* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vneg.s16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t a)
 {
   return vnegq_s16 (a);
 }
 
-/* { dg-final { scan-assembler "vneg.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vneg.s16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t a)
 {
   return vnegq (a);
 }
 
-/* { dg-final { scan-assembler "vneg.s16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_s32.c
index 50401f5..f868257 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_s32.c
@@ -1,21 +1,41 @@
-/* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
-/* { dg-add-options arm_v8_1m_mve_fp } */
+/* { dg-require-effective-target arm_v8_1m_mve_ok } */
+/* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vneg.s32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t a)
 {
   return vnegq_s32 (a);
 }
 
-/* { dg-final { scan-assembler "vneg.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vneg.s32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t a)
 {
   return vnegq (a);
 }
 
-/* { dg-final { scan-assembler "vneg.s32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_s8.c
index fd5de3d..1be5901 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_s8.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vneg.s8	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t a)
 {
   return vnegq_s8 (a);
 }
 
-/* { dg-final { scan-assembler "vneg.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vneg.s8	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t a)
 {
   return vnegq (a);
 }
 
-/* { dg-final { scan-assembler "vneg.s8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_x_f16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_x_f16.c
index e7af366..c10d6d2 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_x_f16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_x_f16.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vnegt.f16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo (float16x8_t a, mve_pred16_t p)
 {
   return vnegq_x_f16 (a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vnegt.f16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vnegt.f16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 float16x8_t
 foo1 (float16x8_t a, mve_pred16_t p)
 {
   return vnegq_x (a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_x_f32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_x_f32.c
index d9c3818..0ee5ecc 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_x_f32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_x_f32.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
 /* { dg-add-options arm_v8_1m_mve_fp } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vnegt.f32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo (float32x4_t a, mve_pred16_t p)
 {
   return vnegq_x_f32 (a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vnegt.f32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vnegt.f32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 float32x4_t
 foo1 (float32x4_t a, mve_pred16_t p)
 {
   return vnegq_x (a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_x_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_x_s16.c
index 16f1fa4..d774a05 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_x_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_x_s16.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vnegt.s16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t a, mve_pred16_t p)
 {
   return vnegq_x_s16 (a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vnegt.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vnegt.s16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t a, mve_pred16_t p)
 {
   return vnegq_x (a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_x_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_x_s32.c
index d74683c..77bf1a6 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_x_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_x_s32.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vnegt.s32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t a, mve_pred16_t p)
 {
   return vnegq_x_s32 (a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vnegt.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vnegt.s32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t a, mve_pred16_t p)
 {
   return vnegq_x (a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_x_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_x_s8.c
index eda4c7f..ca44512 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_x_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vnegq_x_s8.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vnegt.s8	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t a, mve_pred16_t p)
 {
   return vnegq_x_s8 (a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vnegt.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vnegt.s8	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t a, mve_pred16_t p)
 {
   return vnegq_x (a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqabsq_m_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqabsq_m_s16.c
index e74e04a..7172ac5 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqabsq_m_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqabsq_m_s16.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqabst.s16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t inactive, int16x8_t a, mve_pred16_t p)
 {
   return vqabsq_m_s16 (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqabst.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqabst.s16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t inactive, int16x8_t a, mve_pred16_t p)
 {
   return vqabsq_m (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqabsq_m_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqabsq_m_s32.c
index f6ca8a6..297cb19 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqabsq_m_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqabsq_m_s32.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqabst.s32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t inactive, int32x4_t a, mve_pred16_t p)
 {
   return vqabsq_m_s32 (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqabst.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqabst.s32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t inactive, int32x4_t a, mve_pred16_t p)
 {
   return vqabsq_m (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqabsq_m_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqabsq_m_s8.c
index d89a5aa..83c6993 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqabsq_m_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqabsq_m_s8.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqabst.s8	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t inactive, int8x16_t a, mve_pred16_t p)
 {
   return vqabsq_m_s8 (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqabst.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqabst.s8	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t inactive, int8x16_t a, mve_pred16_t p)
 {
   return vqabsq_m (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqabsq_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqabsq_s16.c
index e67c008..bf849fe9 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqabsq_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqabsq_s16.c
@@ -1,21 +1,41 @@
-/* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
-/* { dg-add-options arm_v8_1m_mve_fp } */
+/* { dg-require-effective-target arm_v8_1m_mve_ok } */
+/* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqabs.s16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t a)
 {
   return vqabsq_s16 (a);
 }
 
-/* { dg-final { scan-assembler "vqabs.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqabs.s16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t a)
 {
   return vqabsq (a);
 }
 
-/* { dg-final { scan-assembler "vqabs.s16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqabsq_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqabsq_s32.c
index 8023ff8..1f88821 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqabsq_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqabsq_s32.c
@@ -1,21 +1,41 @@
-/* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
-/* { dg-add-options arm_v8_1m_mve_fp } */
+/* { dg-require-effective-target arm_v8_1m_mve_ok } */
+/* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqabs.s32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t a)
 {
   return vqabsq_s32 (a);
 }
 
-/* { dg-final { scan-assembler "vqabs.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqabs.s32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t a)
 {
   return vqabsq (a);
 }
 
-/* { dg-final { scan-assembler "vqabs.s32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqabsq_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqabsq_s8.c
index b36d2b7..1399f7c 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqabsq_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqabsq_s8.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqabs.s8	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t a)
 {
   return vqabsq_s8 (a);
 }
 
-/* { dg-final { scan-assembler "vqabs.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqabs.s8	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t a)
 {
   return vqabsq (a);
 }
 
-/* { dg-final { scan-assembler "vqabs.s8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_n_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_n_s16.c
index 0fac7ab..17b28cf 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_n_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_n_s16.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (int16x8_t a, int16_t b)
   return vqaddq (a, b);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_n_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_n_s32.c
index d750b1f..e6bb4e0 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_n_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_n_s32.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (int32x4_t a, int32_t b)
   return vqaddq (a, b);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_n_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_n_s8.c
index 5fc796e..f39451f 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_n_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_n_s8.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (int8x16_t a, int8_t b)
   return vqaddq (a, b);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_n_u16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_n_u16.c
index decad65..a87163c 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_n_u16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_n_u16.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -42,4 +46,8 @@ foo2 (uint16x8_t a)
   return vqaddq (a, 1);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_n_u32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_n_u32.c
index b0a6d79..a6aa9b5d 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_n_u32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_n_u32.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -42,4 +46,8 @@ foo2 (uint32x4_t a)
   return vqaddq (a, 1);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_n_u8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_n_u8.c
index f9ca9a1..4bd4731 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_n_u8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_n_u8.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -42,4 +46,8 @@ foo2 (uint8x16_t a)
   return vqaddq (a, 1);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_s16.c
index ffa3146..97e2a60 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_s16.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (int16x8_t a, int16x8_t b)
   return vqaddq (a, b);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_s32.c
index c5937a9..db9355d 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_s32.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (int32x4_t a, int32x4_t b)
   return vqaddq (a, b);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_s8.c
index 9f93751..2804d66 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_s8.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (int8x16_t a, int8x16_t b)
   return vqaddq (a, b);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_u16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_u16.c
index aa4be43..17e5996 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_u16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_u16.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (uint16x8_t a, uint16x8_t b)
   return vqaddq (a, b);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_u32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_u32.c
index daef60e..ce3a397 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_u32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_u32.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (uint32x4_t a, uint32x4_t b)
   return vqaddq (a, b);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_u8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_u8.c
index e28807e..faa881f 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_u8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqaddq_u8.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (uint8x16_t a, uint8x16_t b)
   return vqaddq (a, b);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhq_m_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhq_m_s16.c
index 51cdadc..aa9c78c 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhq_m_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhq_m_s16.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqdmladht.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t inactive, int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vqdmladhq_m_s16 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqdmladht.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqdmladht.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t inactive, int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vqdmladhq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqdmladht.s16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhq_m_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhq_m_s32.c
index 7e43fed..4694a6f 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhq_m_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhq_m_s32.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqdmladht.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t inactive, int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vqdmladhq_m_s32 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqdmladht.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqdmladht.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t inactive, int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vqdmladhq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqdmladht.s32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhq_m_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhq_m_s8.c
index adf5910..c8dc67f 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhq_m_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhq_m_s8.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqdmladht.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t inactive, int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vqdmladhq_m_s8 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqdmladht.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqdmladht.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t inactive, int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vqdmladhq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqdmladht.s8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhq_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhq_s16.c
index 2dc453b..74ebbfa 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhq_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhq_s16.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqdmladh.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t inactive, int16x8_t a, int16x8_t b)
 {
   return vqdmladhq_s16 (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqdmladh.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqdmladh.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t inactive, int16x8_t a, int16x8_t b)
 {
   return vqdmladhq (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqdmladh.s16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhq_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhq_s32.c
index 06f3204..796de4d 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhq_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhq_s32.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqdmladh.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t inactive, int32x4_t a, int32x4_t b)
 {
   return vqdmladhq_s32 (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqdmladh.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqdmladh.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t inactive, int32x4_t a, int32x4_t b)
 {
   return vqdmladhq (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqdmladh.s32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhq_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhq_s8.c
index 79670b8..d585f5f 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhq_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhq_s8.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqdmladh.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t inactive, int8x16_t a, int8x16_t b)
 {
   return vqdmladhq_s8 (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqdmladh.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqdmladh.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t inactive, int8x16_t a, int8x16_t b)
 {
   return vqdmladhq (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqdmladh.s8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhxq_m_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhxq_m_s16.c
index c2446e6..19c5ce5 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhxq_m_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhxq_m_s16.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqdmladhxt.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t inactive, int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vqdmladhxq_m_s16 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqdmladhxt.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqdmladhxt.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t inactive, int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vqdmladhxq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqdmladhxt.s16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhxq_m_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhxq_m_s32.c
index 12b4551..e00162a 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhxq_m_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhxq_m_s32.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqdmladhxt.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t inactive, int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vqdmladhxq_m_s32 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqdmladhxt.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqdmladhxt.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t inactive, int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vqdmladhxq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqdmladhxt.s32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhxq_m_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhxq_m_s8.c
index 146aa51..19767d2 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhxq_m_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhxq_m_s8.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqdmladhxt.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t inactive, int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vqdmladhxq_m_s8 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqdmladhxt.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqdmladhxt.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t inactive, int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vqdmladhxq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqdmladhxt.s8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhxq_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhxq_s16.c
index 5a6f445..c6a2fa8 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhxq_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhxq_s16.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqdmladhx.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t inactive, int16x8_t a, int16x8_t b)
 {
   return vqdmladhxq_s16 (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqdmladhx.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqdmladhx.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t inactive, int16x8_t a, int16x8_t b)
 {
   return vqdmladhxq (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqdmladhx.s16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhxq_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhxq_s32.c
index 4eafa6f..d38bd69 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhxq_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhxq_s32.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqdmladhx.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t inactive, int32x4_t a, int32x4_t b)
 {
   return vqdmladhxq_s32 (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqdmladhx.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqdmladhx.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t inactive, int32x4_t a, int32x4_t b)
 {
   return vqdmladhxq (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqdmladhx.s32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhxq_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhxq_s8.c
index cc66435..322f702 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhxq_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmladhxq_s8.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqdmladhx.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t inactive, int8x16_t a, int8x16_t b)
 {
   return vqdmladhxq_s8 (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqdmladhx.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqdmladhx.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t inactive, int8x16_t a, int8x16_t b)
 {
   return vqdmladhxq (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqdmladhx.s8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlahq_n_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlahq_n_s16.c
index 210bace..909631c 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlahq_n_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlahq_n_s16.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (int16x8_t add, int16x8_t m1, int16_t m2)
   return vqdmlahq (add, m1, m2);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlahq_n_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlahq_n_s32.c
index dbb2494..fb670be 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlahq_n_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlahq_n_s32.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (int32x4_t add, int32x4_t m1, int32_t m2)
   return vqdmlahq (add, m1, m2);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlahq_n_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlahq_n_s8.c
index a7962f8..f66740b 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlahq_n_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlahq_n_s8.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (int8x16_t add, int8x16_t m1, int8_t m2)
   return vqdmlahq (add, m1, m2);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlashq_m_n_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlashq_m_n_s16.c
index 34d407f..918de95 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlashq_m_n_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlashq_m_n_s16.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -38,4 +42,8 @@ foo1 (int16x8_t m1, int16x8_t m2, int16_t add, mve_pred16_t p)
   return vqdmlashq_m (m1, m2, add, p);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlashq_m_n_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlashq_m_n_s32.c
index 50a665e..b25b660 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlashq_m_n_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlashq_m_n_s32.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -38,4 +42,8 @@ foo1 (int32x4_t m1, int32x4_t m2, int32_t add, mve_pred16_t p)
   return vqdmlashq_m (m1, m2, add, p);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlashq_m_n_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlashq_m_n_s8.c
index 45f34b6..b796f20 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlashq_m_n_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlashq_m_n_s8.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -38,4 +42,8 @@ foo1 (int8x16_t m1, int8x16_t m2, int8_t add, mve_pred16_t p)
   return vqdmlashq_m (m1, m2, add, p);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlashq_n_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlashq_n_s16.c
index a3f1ae8..9a25494 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlashq_n_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlashq_n_s16.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (int16x8_t m1, int16x8_t m2, int16_t add)
   return vqdmlashq (m1, m2, add);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlashq_n_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlashq_n_s32.c
index cf867e5..36fc7b0 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlashq_n_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlashq_n_s32.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (int32x4_t m1, int32x4_t m2, int32_t add)
   return vqdmlashq (m1, m2, add);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlashq_n_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlashq_n_s8.c
index 7e9362c..1e7cd44 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlashq_n_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlashq_n_s8.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (int8x16_t m1, int8x16_t m2, int8_t add)
   return vqdmlashq (m1, m2, add);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhq_m_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhq_m_s16.c
index d1e6686..f87287a 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhq_m_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhq_m_s16.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqdmlsdht.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t inactive, int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vqdmlsdhq_m_s16 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqdmlsdht.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqdmlsdht.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t inactive, int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vqdmlsdhq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqdmlsdht.s16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhq_m_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhq_m_s32.c
index cc80f21..8155aaf 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhq_m_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhq_m_s32.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqdmlsdht.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t inactive, int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vqdmlsdhq_m_s32 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqdmlsdht.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqdmlsdht.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t inactive, int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vqdmlsdhq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqdmlsdht.s32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhq_m_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhq_m_s8.c
index 5c9d81a..d39badc 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhq_m_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhq_m_s8.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqdmlsdht.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t inactive, int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vqdmlsdhq_m_s8 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqdmlsdht.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqdmlsdht.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t inactive, int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vqdmlsdhq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqdmlsdht.s8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhq_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhq_s16.c
index eb058fb..a4fa1d5 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhq_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhq_s16.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqdmlsdh.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t inactive, int16x8_t a, int16x8_t b)
 {
   return vqdmlsdhq_s16 (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqdmlsdh.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqdmlsdh.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t inactive, int16x8_t a, int16x8_t b)
 {
   return vqdmlsdhq (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqdmlsdh.s16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhq_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhq_s32.c
index 27b93d6..0c6ba42 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhq_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhq_s32.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqdmlsdh.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t inactive, int32x4_t a, int32x4_t b)
 {
   return vqdmlsdhq_s32 (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqdmlsdh.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqdmlsdh.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t inactive, int32x4_t a, int32x4_t b)
 {
   return vqdmlsdhq (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqdmlsdh.s32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhq_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhq_s8.c
index 1dd2a59..089c4cd 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhq_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhq_s8.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqdmlsdh.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t inactive, int8x16_t a, int8x16_t b)
 {
   return vqdmlsdhq_s8 (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqdmlsdh.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqdmlsdh.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t inactive, int8x16_t a, int8x16_t b)
 {
   return vqdmlsdhq (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqdmlsdh.s8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhxq_m_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhxq_m_s16.c
index 6ab9743..1742d47 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhxq_m_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhxq_m_s16.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqdmlsdhxt.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t inactive, int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vqdmlsdhxq_m_s16 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqdmlsdhxt.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqdmlsdhxt.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t inactive, int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vqdmlsdhxq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqdmlsdhxt.s16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhxq_m_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhxq_m_s32.c
index a34618e..1c1b73a 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhxq_m_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhxq_m_s32.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqdmlsdhxt.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t inactive, int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vqdmlsdhxq_m_s32 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqdmlsdhxt.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqdmlsdhxt.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t inactive, int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vqdmlsdhxq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqdmlsdhxt.s32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhxq_m_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhxq_m_s8.c
index fdbe89a..0a980a0 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhxq_m_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhxq_m_s8.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqdmlsdhxt.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t inactive, int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vqdmlsdhxq_m_s8 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqdmlsdhxt.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqdmlsdhxt.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t inactive, int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vqdmlsdhxq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqdmlsdhxt.s8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhxq_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhxq_s16.c
index 786decc..713ce97 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhxq_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhxq_s16.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqdmlsdhx.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t inactive, int16x8_t a, int16x8_t b)
 {
   return vqdmlsdhxq_s16 (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqdmlsdhx.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqdmlsdhx.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t inactive, int16x8_t a, int16x8_t b)
 {
   return vqdmlsdhxq (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqdmlsdhx.s16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhxq_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhxq_s32.c
index c0244c4..02f0a3c 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhxq_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhxq_s32.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqdmlsdhx.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t inactive, int32x4_t a, int32x4_t b)
 {
   return vqdmlsdhxq_s32 (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqdmlsdhx.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqdmlsdhx.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t inactive, int32x4_t a, int32x4_t b)
 {
   return vqdmlsdhxq (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqdmlsdhx.s32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhxq_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhxq_s8.c
index 12b43c8..c179287 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhxq_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqdmlsdhxq_s8.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqdmlsdhx.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t inactive, int8x16_t a, int8x16_t b)
 {
   return vqdmlsdhxq_s8 (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqdmlsdhx.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqdmlsdhx.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t inactive, int8x16_t a, int8x16_t b)
 {
   return vqdmlsdhxq (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqdmlsdhx.s8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqnegq_m_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqnegq_m_s16.c
index 4f0145d..f3799a3 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqnegq_m_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqnegq_m_s16.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqnegt.s16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t inactive, int16x8_t a, mve_pred16_t p)
 {
   return vqnegq_m_s16 (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqnegt.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqnegt.s16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t inactive, int16x8_t a, mve_pred16_t p)
 {
   return vqnegq_m (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqnegq_m_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqnegq_m_s32.c
index da4f90b..bbe64ff 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqnegq_m_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqnegq_m_s32.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqnegt.s32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t inactive, int32x4_t a, mve_pred16_t p)
 {
   return vqnegq_m_s32 (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqnegt.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqnegt.s32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t inactive, int32x4_t a, mve_pred16_t p)
 {
   return vqnegq_m (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqnegq_m_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqnegq_m_s8.c
index ac1250b..71fcdd7 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqnegq_m_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqnegq_m_s8.c
@@ -1,22 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqnegt.s8	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t inactive, int8x16_t a, mve_pred16_t p)
 {
   return vqnegq_m_s8 (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqnegt.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqnegt.s8	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t inactive, int8x16_t a, mve_pred16_t p)
 {
   return vqnegq_m (inactive, a, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqnegq_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqnegq_s16.c
index f9210cd..d5fb4a1 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqnegq_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqnegq_s16.c
@@ -1,21 +1,41 @@
-/* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
-/* { dg-add-options arm_v8_1m_mve_fp } */
+/* { dg-require-effective-target arm_v8_1m_mve_ok } */
+/* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqneg.s16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t a)
 {
   return vqnegq_s16 (a);
 }
 
-/* { dg-final { scan-assembler "vqneg.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqneg.s16	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t a)
 {
   return vqnegq (a);
 }
 
-/* { dg-final { scan-assembler "vqneg.s16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqnegq_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqnegq_s32.c
index c2ded7f..2c8e709 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqnegq_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqnegq_s32.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqneg.s32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t a)
 {
   return vqnegq_s32 (a);
 }
 
-/* { dg-final { scan-assembler "vqneg.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqneg.s32	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t a)
 {
   return vqnegq (a);
 }
 
-/* { dg-final { scan-assembler "vqneg.s32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqnegq_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqnegq_s8.c
index d1cc83a..2f7f761 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqnegq_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqnegq_s8.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqneg.s8	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t a)
 {
   return vqnegq_s8 (a);
 }
 
-/* { dg-final { scan-assembler "vqneg.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqneg.s8	q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t a)
 {
   return vqnegq (a);
 }
 
-/* { dg-final { scan-assembler "vqneg.s8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhq_m_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhq_m_s16.c
index fce4f5a..5b0e134 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhq_m_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhq_m_s16.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmladht.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t inactive, int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vqrdmladhq_m_s16 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmladht.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmladht.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t inactive, int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vqrdmladhq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmladht.s16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhq_m_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhq_m_s32.c
index e550b6a..6fdf387 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhq_m_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhq_m_s32.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmladht.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t inactive, int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vqrdmladhq_m_s32 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmladht.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmladht.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t inactive, int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vqrdmladhq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmladht.s32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhq_m_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhq_m_s8.c
index b07b28e..ef75f73 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhq_m_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhq_m_s8.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmladht.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t inactive, int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vqrdmladhq_m_s8 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmladht.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmladht.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t inactive, int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vqrdmladhq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmladht.s8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhq_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhq_s16.c
index 5bdac92..cf7cdb2 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhq_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhq_s16.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqrdmladh.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t inactive, int16x8_t a, int16x8_t b)
 {
   return vqrdmladhq_s16 (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmladh.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqrdmladh.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t inactive, int16x8_t a, int16x8_t b)
 {
   return vqrdmladhq (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmladh.s16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhq_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhq_s32.c
index aade9bb..5a022fe 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhq_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhq_s32.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqrdmladh.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t inactive, int32x4_t a, int32x4_t b)
 {
   return vqrdmladhq_s32 (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmladh.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqrdmladh.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t inactive, int32x4_t a, int32x4_t b)
 {
   return vqrdmladhq (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmladh.s32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhq_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhq_s8.c
index bde80fa..2cb27df 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhq_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhq_s8.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqrdmladh.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t inactive, int8x16_t a, int8x16_t b)
 {
   return vqrdmladhq_s8 (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmladh.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqrdmladh.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t inactive, int8x16_t a, int8x16_t b)
 {
   return vqrdmladhq (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmladh.s8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhxq_m_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhxq_m_s16.c
index 677efdc..1f68671 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhxq_m_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhxq_m_s16.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmladhxt.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t inactive, int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vqrdmladhxq_m_s16 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmladhxt.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmladhxt.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t inactive, int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vqrdmladhxq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmladhxt.s16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhxq_m_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhxq_m_s32.c
index 8ee8bbb..eaea6e1 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhxq_m_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhxq_m_s32.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmladhxt.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t inactive, int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vqrdmladhxq_m_s32 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmladhxt.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmladhxt.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t inactive, int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vqrdmladhxq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmladhxt.s32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhxq_m_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhxq_m_s8.c
index 7cfa88f..0f582a9 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhxq_m_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhxq_m_s8.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmladhxt.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t inactive, int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vqrdmladhxq_m_s8 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmladhxt.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmladhxt.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t inactive, int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vqrdmladhxq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmladhxt.s8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhxq_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhxq_s16.c
index 2410ef1..a26898e 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhxq_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhxq_s16.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqrdmladhx.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t inactive, int16x8_t a, int16x8_t b)
 {
   return vqrdmladhxq_s16 (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmladhx.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqrdmladhx.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t inactive, int16x8_t a, int16x8_t b)
 {
   return vqrdmladhxq (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmladhx.s16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhxq_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhxq_s32.c
index 716028c..572486e 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhxq_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhxq_s32.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqrdmladhx.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t inactive, int32x4_t a, int32x4_t b)
 {
   return vqrdmladhxq_s32 (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmladhx.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqrdmladhx.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t inactive, int32x4_t a, int32x4_t b)
 {
   return vqrdmladhxq (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmladhx.s32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhxq_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhxq_s8.c
index 8f9bed5..00e478b 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhxq_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmladhxq_s8.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqrdmladhx.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t inactive, int8x16_t a, int8x16_t b)
 {
   return vqrdmladhxq_s8 (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmladhx.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqrdmladhx.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t inactive, int8x16_t a, int8x16_t b)
 {
   return vqrdmladhxq (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmladhx.s8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlashq_n_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlashq_n_s16.c
index 8ff8c34..2710f2f 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlashq_n_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlashq_n_s16.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqrdmlash.s16	q[0-9]+, q[0-9]+, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+*/
 int16x8_t
-foo (int16x8_t a, int16x8_t b, int16_t c)
+foo (int16x8_t m1, int16x8_t m2, int16_t add)
 {
-  return vqrdmlashq_n_s16 (a, b, c);
+  return vqrdmlashq_n_s16 (m1, m2, add);
 }
 
-/* { dg-final { scan-assembler "vqrdmlash.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqrdmlash.s16	q[0-9]+, q[0-9]+, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+*/
 int16x8_t
-foo1 (int16x8_t a, int16x8_t b, int16_t c)
+foo1 (int16x8_t m1, int16x8_t m2, int16_t add)
 {
-  return vqrdmlashq (a, b, c);
+  return vqrdmlashq (m1, m2, add);
+}
+
+#ifdef __cplusplus
 }
+#endif
 
-/* { dg-final { scan-assembler "vqrdmlash.s16"  }  } */
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlashq_n_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlashq_n_s32.c
index 02583f0..5fefc39 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlashq_n_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlashq_n_s32.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqrdmlash.s32	q[0-9]+, q[0-9]+, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+*/
 int32x4_t
-foo (int32x4_t a, int32x4_t b, int32_t c)
+foo (int32x4_t m1, int32x4_t m2, int32_t add)
 {
-  return vqrdmlashq_n_s32 (a, b, c);
+  return vqrdmlashq_n_s32 (m1, m2, add);
 }
 
-/* { dg-final { scan-assembler "vqrdmlash.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqrdmlash.s32	q[0-9]+, q[0-9]+, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+*/
 int32x4_t
-foo1 (int32x4_t a, int32x4_t b, int32_t c)
+foo1 (int32x4_t m1, int32x4_t m2, int32_t add)
 {
-  return vqrdmlashq (a, b, c);
+  return vqrdmlashq (m1, m2, add);
+}
+
+#ifdef __cplusplus
 }
+#endif
 
-/* { dg-final { scan-assembler "vqrdmlash.s32"  }  } */
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlashq_n_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlashq_n_s8.c
index 0bd5bca..df96fe8 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlashq_n_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlashq_n_s8.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqrdmlash.s8	q[0-9]+, q[0-9]+, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+*/
 int8x16_t
-foo (int8x16_t a, int8x16_t b, int8_t c)
+foo (int8x16_t m1, int8x16_t m2, int8_t add)
 {
-  return vqrdmlashq_n_s8 (a, b, c);
+  return vqrdmlashq_n_s8 (m1, m2, add);
 }
 
-/* { dg-final { scan-assembler "vqrdmlash.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqrdmlash.s8	q[0-9]+, q[0-9]+, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+*/
 int8x16_t
-foo1 (int8x16_t a, int8x16_t b, int8_t c)
+foo1 (int8x16_t m1, int8x16_t m2, int8_t add)
 {
-  return vqrdmlashq (a, b, c);
+  return vqrdmlashq (m1, m2, add);
+}
+
+#ifdef __cplusplus
 }
+#endif
 
-/* { dg-final { scan-assembler "vqrdmlash.s8"  }  } */
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhq_m_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhq_m_s16.c
index d0054b8..6a57762 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhq_m_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhq_m_s16.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmlsdht.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t inactive, int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vqrdmlsdhq_m_s16 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmlsdht.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmlsdht.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t inactive, int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vqrdmlsdhq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmlsdht.s16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhq_m_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhq_m_s32.c
index 7d3fe45..9539e24 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhq_m_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhq_m_s32.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmlsdht.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t inactive, int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vqrdmlsdhq_m_s32 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmlsdht.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmlsdht.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t inactive, int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vqrdmlsdhq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmlsdht.s32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhq_m_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhq_m_s8.c
index c33f8ea..69e54f5 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhq_m_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhq_m_s8.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmlsdht.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t inactive, int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vqrdmlsdhq_m_s8 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmlsdht.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmlsdht.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t inactive, int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vqrdmlsdhq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmlsdht.s8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhq_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhq_s16.c
index 3bd760d3..3eb957d 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhq_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhq_s16.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqrdmlsdh.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t inactive, int16x8_t a, int16x8_t b)
 {
   return vqrdmlsdhq_s16 (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmlsdh.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqrdmlsdh.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t inactive, int16x8_t a, int16x8_t b)
 {
   return vqrdmlsdhq (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmlsdh.s16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhq_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhq_s32.c
index e23dc94..3a3fb506 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhq_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhq_s32.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqrdmlsdh.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t inactive, int32x4_t a, int32x4_t b)
 {
   return vqrdmlsdhq_s32 (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmlsdh.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqrdmlsdh.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t inactive, int32x4_t a, int32x4_t b)
 {
   return vqrdmlsdhq (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmlsdh.s32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhq_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhq_s8.c
index 836e04a..65ac15d 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhq_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhq_s8.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqrdmlsdh.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t inactive, int8x16_t a, int8x16_t b)
 {
   return vqrdmlsdhq_s8 (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmlsdh.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqrdmlsdh.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t inactive, int8x16_t a, int8x16_t b)
 {
   return vqrdmlsdhq (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmlsdh.s8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhxq_m_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhxq_m_s16.c
index 2fbd351..3598f50 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhxq_m_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhxq_m_s16.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmlsdhxt.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t inactive, int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vqrdmlsdhxq_m_s16 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmlsdhxt.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmlsdhxt.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t inactive, int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vqrdmlsdhxq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmlsdhxt.s16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhxq_m_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhxq_m_s32.c
index 324a6e6..1ab22ed 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhxq_m_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhxq_m_s32.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmlsdhxt.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t inactive, int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vqrdmlsdhxq_m_s32 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmlsdhxt.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmlsdhxt.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t inactive, int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vqrdmlsdhxq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmlsdhxt.s32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhxq_m_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhxq_m_s8.c
index 287868b..01103e9 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhxq_m_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhxq_m_s8.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmlsdhxt.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t inactive, int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vqrdmlsdhxq_m_s8 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmlsdhxt.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmlsdhxt.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t inactive, int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vqrdmlsdhxq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmlsdhxt.s8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhxq_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhxq_s16.c
index 9d8ea9b..522d0ba 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhxq_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhxq_s16.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqrdmlsdhx.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t inactive, int16x8_t a, int16x8_t b)
 {
   return vqrdmlsdhxq_s16 (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmlsdhx.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqrdmlsdhx.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t inactive, int16x8_t a, int16x8_t b)
 {
   return vqrdmlsdhxq (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmlsdhx.s16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhxq_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhxq_s32.c
index aca0b35..5198dfa 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhxq_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhxq_s32.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqrdmlsdhx.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t inactive, int32x4_t a, int32x4_t b)
 {
   return vqrdmlsdhxq_s32 (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmlsdhx.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqrdmlsdhx.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t inactive, int32x4_t a, int32x4_t b)
 {
   return vqrdmlsdhxq (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmlsdhx.s32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhxq_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhxq_s8.c
index 18f9531..b5baa3d 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhxq_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmlsdhxq_s8.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqrdmlsdhx.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t inactive, int8x16_t a, int8x16_t b)
 {
   return vqrdmlsdhxq_s8 (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmlsdhx.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqrdmlsdhx.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t inactive, int8x16_t a, int8x16_t b)
 {
   return vqrdmlsdhxq (inactive, a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmlsdhx.s8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_m_n_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_m_n_s16.c
index c4b6b7e2..fc3a330 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_m_n_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_m_n_s16.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmulht.s16	q[0-9]+, q[0-9]+, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t inactive, int16x8_t a, int16_t b, mve_pred16_t p)
 {
   return vqrdmulhq_m_n_s16 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmulht.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmulht.s16	q[0-9]+, q[0-9]+, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t inactive, int16x8_t a, int16_t b, mve_pred16_t p)
 {
   return vqrdmulhq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmulht.s16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_m_n_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_m_n_s32.c
index 6de3eb1..897ad5b 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_m_n_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_m_n_s32.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmulht.s32	q[0-9]+, q[0-9]+, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t inactive, int32x4_t a, int32_t b, mve_pred16_t p)
 {
   return vqrdmulhq_m_n_s32 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmulht.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmulht.s32	q[0-9]+, q[0-9]+, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t inactive, int32x4_t a, int32_t b, mve_pred16_t p)
 {
   return vqrdmulhq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmulht.s32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_m_n_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_m_n_s8.c
index df3dfa8..05ab060 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_m_n_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_m_n_s8.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmulht.s8	q[0-9]+, q[0-9]+, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t inactive, int8x16_t a, int8_t b, mve_pred16_t p)
 {
   return vqrdmulhq_m_n_s8 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmulht.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmulht.s8	q[0-9]+, q[0-9]+, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t inactive, int8x16_t a, int8_t b, mve_pred16_t p)
 {
   return vqrdmulhq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmulht.s8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_m_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_m_s16.c
index 24831e8..1d9dc07 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_m_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_m_s16.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmulht.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t inactive, int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vqrdmulhq_m_s16 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmulht.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmulht.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t inactive, int16x8_t a, int16x8_t b, mve_pred16_t p)
 {
   return vqrdmulhq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmulht.s16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_m_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_m_s32.c
index 70257c3..76d7507 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_m_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_m_s32.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmulht.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t inactive, int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vqrdmulhq_m_s32 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmulht.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmulht.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t inactive, int32x4_t a, int32x4_t b, mve_pred16_t p)
 {
   return vqrdmulhq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmulht.s32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_m_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_m_s8.c
index 7cd39d2..7fd2119 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_m_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_m_s8.c
@@ -1,23 +1,49 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmulht.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t inactive, int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vqrdmulhq_m_s8 (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmulht.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vmsr	p0, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+**	vpst(?:	@.*|)
+**	...
+**	vqrdmulht.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t inactive, int8x16_t a, int8x16_t b, mve_pred16_t p)
 {
   return vqrdmulhq_m (inactive, a, b, p);
 }
 
-/* { dg-final { scan-assembler "vpst" } } */
-/* { dg-final { scan-assembler "vqrdmulht.s8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_n_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_n_s16.c
index 42fe9cb..8a90a39 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_n_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_n_s16.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqrdmulh.s16	q[0-9]+, q[0-9]+, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t a, int16_t b)
 {
   return vqrdmulhq_n_s16 (a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmulh.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqrdmulh.s16	q[0-9]+, q[0-9]+, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t a, int16_t b)
 {
   return vqrdmulhq (a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmulh.s16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_n_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_n_s32.c
index 5f014fa..973464b 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_n_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_n_s32.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqrdmulh.s32	q[0-9]+, q[0-9]+, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t a, int32_t b)
 {
   return vqrdmulhq_n_s32 (a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmulh.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqrdmulh.s32	q[0-9]+, q[0-9]+, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t a, int32_t b)
 {
   return vqrdmulhq (a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmulh.s32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_n_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_n_s8.c
index 887e294..65aab96 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_n_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_n_s8.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqrdmulh.s8	q[0-9]+, q[0-9]+, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t a, int8_t b)
 {
   return vqrdmulhq_n_s8 (a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmulh.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqrdmulh.s8	q[0-9]+, q[0-9]+, (?:ip|fp|r[0-9]+)(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t a, int8_t b)
 {
   return vqrdmulhq (a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmulh.s8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_s16.c
index 409fc29..f3153c8 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_s16.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqrdmulh.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo (int16x8_t a, int16x8_t b)
 {
   return vqrdmulhq_s16 (a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmulh.s16"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqrdmulh.s16	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int16x8_t
 foo1 (int16x8_t a, int16x8_t b)
 {
   return vqrdmulhq (a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmulh.s16"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_s32.c
index 18e11b1..48b10db 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_s32.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqrdmulh.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo (int32x4_t a, int32x4_t b)
 {
   return vqrdmulhq_s32 (a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmulh.s32"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqrdmulh.s32	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int32x4_t
 foo1 (int32x4_t a, int32x4_t b)
 {
   return vqrdmulhq (a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmulh.s32"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_s8.c
index 3f1441d..9f0346f 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vqrdmulhq_s8.c
@@ -1,21 +1,41 @@
 /* { dg-require-effective-target arm_v8_1m_mve_ok } */
 /* { dg-add-options arm_v8_1m_mve } */
 /* { dg-additional-options "-O2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+**foo:
+**	...
+**	vqrdmulh.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo (int8x16_t a, int8x16_t b)
 {
   return vqrdmulhq_s8 (a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmulh.s8"  }  } */
 
+/*
+**foo1:
+**	...
+**	vqrdmulh.s8	q[0-9]+, q[0-9]+, q[0-9]+(?:	@.*|)
+**	...
+*/
 int8x16_t
 foo1 (int8x16_t a, int8x16_t b)
 {
   return vqrdmulhq (a, b);
 }
 
-/* { dg-final { scan-assembler "vqrdmulh.s8"  }  } */
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_f16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_f16.c
index 6b148a4..5b1731f 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_f16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_f16.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -42,4 +46,8 @@ foo2 (float16x8_t b)
   return vsetq_lane (1.1, b, 1);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_f32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_f32.c
index e4e7f89..34b403d 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_f32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_f32.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -42,4 +46,8 @@ foo2 (float32x4_t b)
   return vsetq_lane (1.1, b, 1);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_s16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_s16.c
index 950cd01..458fd5e 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_s16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_s16.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (int16_t a, int16x8_t b)
   return vsetq_lane (a, b, 1);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_s32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_s32.c
index 6b49ccd..44672f6c 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_s32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_s32.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (int32_t a, int32x4_t b)
   return vsetq_lane (a, b, 1);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_s64.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_s64.c
index 95ba4da..62e8ee5 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_s64.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_s64.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (int64_t a, int64x2_t b)
   return vsetq_lane (a, b, 1);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_s8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_s8.c
index 91a5bae..3a79ab1 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_s8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_s8.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -30,4 +34,8 @@ foo1 (int8_t a, int8x16_t b)
   return vsetq_lane (a, b, 1);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_u16.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_u16.c
index 53986a5..8a42773 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_u16.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_u16.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -42,4 +46,8 @@ foo2 (uint16x8_t b)
   return vsetq_lane (1, b, 1);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_u32.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_u32.c
index 3f17db9..43778e6 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_u32.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_u32.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -42,4 +46,8 @@ foo2 (uint32x4_t b)
   return vsetq_lane (1, b, 1);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_u64.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_u64.c
index 5ce4c54..c75bfa4 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_u64.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_u64.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -42,4 +46,8 @@ foo2 (uint64x2_t b)
   return vsetq_lane (1, b, 1);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_u8.c b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_u8.c
index 58e932b..5fb2016 100644
--- a/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_u8.c
+++ b/gcc/testsuite/gcc.target/arm/mve/intrinsics/vsetq_lane_u8.c
@@ -5,6 +5,10 @@
 
 #include "arm_mve.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 **foo:
 **	...
@@ -42,4 +46,8 @@ foo2 (uint8x16_t b)
   return vsetq_lane (1, b, 1);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 /* { dg-final { scan-assembler-not "__ARM_undef" } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/arm/mve/pr108177-1-run.c b/gcc/testsuite/gcc.target/arm/mve/pr108177-1-run.c
new file mode 100644
index 0000000..ca092df
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/mve/pr108177-1-run.c
@@ -0,0 +1,6 @@
+/* { dg-do run } */
+/* { dg-require-effective-target arm_mve_hw } */
+/* { dg-options "-O2 --save-temps" } */
+/* { dg-add-options arm_v8_1m_mve } */
+
+#include "pr108177-1.c"
diff --git a/gcc/testsuite/gcc.target/arm/mve/pr108177-1.c b/gcc/testsuite/gcc.target/arm/mve/pr108177-1.c
new file mode 100644
index 0000000..2d42062
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/mve/pr108177-1.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target arm_v8_1m_mve_ok } */
+/* { dg-options "-O2" } */
+/* { dg-add-options arm_v8_1m_mve } */
+/* { dg-final { check-function-bodies "**" "" "" } } */
+
+/*
+** test:
+**...
+**	vstrbt.8	q0, \[r0\]
+**...
+**	vstrbt.8	q0, \[r0\]
+**...
+*/
+
+#define TYPE uint8x16_t
+#define INTRINSIC vstrbq_u8
+#define INTRINSIC_P vstrbq_p_u8
+
+#include "pr108177.x"
diff --git a/gcc/testsuite/gcc.target/arm/mve/pr108177-10-run.c b/gcc/testsuite/gcc.target/arm/mve/pr108177-10-run.c
new file mode 100644
index 0000000..0a58b8f
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/mve/pr108177-10-run.c
@@ -0,0 +1,6 @@
+/* { dg-do run } */
+/* { dg-require-effective-target arm_mve_hw } */
+/* { dg-options "-O2" } */
+/* { dg-add-options arm_v8_1m_mve } */
+
+#include "pr108177-10.c"
diff --git a/gcc/testsuite/gcc.target/arm/mve/pr108177-10.c b/gcc/testsuite/gcc.target/arm/mve/pr108177-10.c
new file mode 100644
index 0000000..4db594f
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/mve/pr108177-10.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target arm_v8_1m_mve_ok } */
+/* { dg-options "-O2" } */
+/* { dg-add-options arm_v8_1m_mve } */
+/* { dg-final { check-function-bodies "**" "" "" } } */
+
+/*
+** test:
+**...
+**	vstrht.32	q0, \[r0\]
+**...
+**	vstrht.32	q0, \[r0\]
+**...
+*/
+
+#define TYPE int32x4_t
+#define INTRINSIC vstrhq_s32
+#define INTRINSIC_P vstrhq_p_s32
+
+#include "pr108177.x"
diff --git a/gcc/testsuite/gcc.target/arm/mve/pr108177-11-run.c b/gcc/testsuite/gcc.target/arm/mve/pr108177-11-run.c
new file mode 100644
index 0000000..9f568ea
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/mve/pr108177-11-run.c
@@ -0,0 +1,6 @@
+/* { dg-do run } */
+/* { dg-require-effective-target arm_mve_hw } */
+/* { dg-options "-O2" } */
+/* { dg-add-options arm_v8_1m_mve } */
+
+#include "pr108177-11.c"
diff --git a/gcc/testsuite/gcc.target/arm/mve/pr108177-11.c b/gcc/testsuite/gcc.target/arm/mve/pr108177-11.c
new file mode 100644
index 0000000..329fcb3
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/mve/pr108177-11.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target arm_v8_1m_mve_ok } */
+/* { dg-options "-O2" } */
+/* { dg-add-options arm_v8_1m_mve } */
+/* { dg-final { check-function-bodies "**" "" "" } } */
+
+/*
+** test:
+**...
+**	vstrwt.32	q0, \[r0\]
+**...
+**	vstrwt.32	q0, \[r0\]
+**...
+*/
+
+#define TYPE uint32x4_t
+#define INTRINSIC vstrwq_u32
+#define INTRINSIC_P vstrwq_p_u32
+
+#include "pr108177.x"
diff --git a/gcc/testsuite/gcc.target/arm/mve/pr108177-12-run.c b/gcc/testsuite/gcc.target/arm/mve/pr108177-12-run.c
new file mode 100644
index 0000000..8e946a2
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/mve/pr108177-12-run.c
@@ -0,0 +1,6 @@
+/* { dg-do run } */
+/* { dg-require-effective-target arm_mve_hw } */
+/* { dg-options "-O2" } */
+/* { dg-add-options arm_v8_1m_mve } */
+
+#include "pr108177-12.c"
diff --git a/gcc/testsuite/gcc.target/arm/mve/pr108177-12.c b/gcc/testsuite/gcc.target/arm/mve/pr108177-12.c
new file mode 100644
index 0000000..3f7c5b2
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/mve/pr108177-12.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target arm_v8_1m_mve_ok } */
+/* { dg-options "-O2" } */
+/* { dg-add-options arm_v8_1m_mve } */
+/* { dg-final { check-function-bodies "**" "" "" } } */
+
+/*
+** test:
+**...
+**	vstrwt.32	q0, \[r0\]
+**...
+**	vstrwt.32	q0, \[r0\]
+**...
+*/
+
+#define TYPE int32x4_t
+#define INTRINSIC vstrwq_s32
+#define INTRINSIC_P vstrwq_p_s32
+
+#include "pr108177.x"
diff --git a/gcc/testsuite/gcc.target/arm/mve/pr108177-13-run.c b/gcc/testsuite/gcc.target/arm/mve/pr108177-13-run.c
new file mode 100644
index 0000000..2e731ee
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/mve/pr108177-13-run.c
@@ -0,0 +1,6 @@
+/* { dg-do run } */
+/* { dg-require-effective-target arm_mve_hw } */
+/* { dg-options "-O2" } */
+/* { dg-add-options arm_v8_1m_mve } */
+
+#include "pr108177-13.c"
diff --git a/gcc/testsuite/gcc.target/arm/mve/pr108177-13.c b/gcc/testsuite/gcc.target/arm/mve/pr108177-13.c
new file mode 100644
index 0000000..2f82228
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/mve/pr108177-13.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
+/* { dg-options "-O2" } */
+/* { dg-add-options arm_v8_1m_mve_fp } */
+/* { dg-final { check-function-bodies "**" "" "" } } */
+
+/*
+** test:
+**...
+**	vstrht.16	q0, \[r0\]
+**...
+**	vstrht.16	q0, \[r0\]
+**...
+*/
+
+#define TYPE float16x8_t
+#define INTRINSIC vstrhq_f16
+#define INTRINSIC_P vstrhq_p_f16
+
+#include "pr108177.x"
diff --git a/gcc/testsuite/gcc.target/arm/mve/pr108177-14-run.c b/gcc/testsuite/gcc.target/arm/mve/pr108177-14-run.c
new file mode 100644
index 0000000..3cebcf5
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/mve/pr108177-14-run.c
@@ -0,0 +1,6 @@
+/* { dg-do run } */
+/* { dg-require-effective-target arm_mve_hw } */
+/* { dg-options "-O2" } */
+/* { dg-add-options arm_v8_1m_mve } */
+
+#include "pr108177-14.c"
diff --git a/gcc/testsuite/gcc.target/arm/mve/pr108177-14.c b/gcc/testsuite/gcc.target/arm/mve/pr108177-14.c
new file mode 100644
index 0000000..ba6196b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/mve/pr108177-14.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
+/* { dg-options "-O2" } */
+/* { dg-add-options arm_v8_1m_mve_fp } */
+/* { dg-final { check-function-bodies "**" "" "" } } */
+
+/*
+** test:
+**...
+**	vstrwt.32	q0, \[r0\]
+**...
+**	vstrwt.32	q0, \[r0\]
+**...
+*/
+
+#define TYPE float32x4_t
+#define INTRINSIC vstrwq_f32
+#define INTRINSIC_P vstrwq_p_f32
+
+#include "pr108177.x"
diff --git a/gcc/testsuite/gcc.target/arm/mve/pr108177-2-run.c b/gcc/testsuite/gcc.target/arm/mve/pr108177-2-run.c
new file mode 100644
index 0000000..03750c9
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/mve/pr108177-2-run.c
@@ -0,0 +1,6 @@
+/* { dg-do run } */
+/* { dg-require-effective-target arm_mve_hw } */
+/* { dg-options "-O2" } */
+/* { dg-add-options arm_v8_1m_mve } */
+
+#include "pr108177-2.c"
diff --git a/gcc/testsuite/gcc.target/arm/mve/pr108177-2.c b/gcc/testsuite/gcc.target/arm/mve/pr108177-2.c
new file mode 100644
index 0000000..52c8d87
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/mve/pr108177-2.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target arm_v8_1m_mve_ok } */
+/* { dg-options "-O2" } */
+/* { dg-add-options arm_v8_1m_mve } */
+/* { dg-final { check-function-bodies "**" "" "" } } */
+
+/*
+** test:
+**...
+**	vstrbt.8	q0, \[r0\]
+**...
+**	vstrbt.8	q0, \[r0\]
+**...
+*/
+
+#define TYPE int8x16_t
+#define INTRINSIC vstrbq_s8
+#define INTRINSIC_P vstrbq_p_s8
+
+#include "pr108177.x"
diff --git a/gcc/testsuite/gcc.target/arm/mve/pr108177-3-run.c b/gcc/testsuite/gcc.target/arm/mve/pr108177-3-run.c
new file mode 100644
index 0000000..bab08e0
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/mve/pr108177-3-run.c
@@ -0,0 +1,6 @@
+/* { dg-do run } */
+/* { dg-require-effective-target arm_mve_hw } */
+/* { dg-options "-O2" } */
+/* { dg-add-options arm_v8_1m_mve } */
+
+#include "pr108177-3.c"
diff --git a/gcc/testsuite/gcc.target/arm/mve/pr108177-3.c b/gcc/testsuite/gcc.target/arm/mve/pr108177-3.c
new file mode 100644
index 0000000..ac89e7e
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/mve/pr108177-3.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target arm_v8_1m_mve_ok } */
+/* { dg-options "-O2" } */
+/* { dg-add-options arm_v8_1m_mve } */
+/* { dg-final { check-function-bodies "**" "" "" } } */
+
+/*
+** test:
+**...
+**	vstrbt.16	q0, \[r0\]
+**...
+**	vstrbt.16	q0, \[r0\]
+**...
+*/
+
+#define TYPE uint16x8_t
+#define INTRINSIC vstrbq_u16
+#define INTRINSIC_P vstrbq_p_u16
+
+#include "pr108177.x"
diff --git a/gcc/testsuite/gcc.target/arm/mve/pr108177-4-run.c b/gcc/testsuite/gcc.target/arm/mve/pr108177-4-run.c
new file mode 100644
index 0000000..cff62c7
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/mve/pr108177-4-run.c
@@ -0,0 +1,6 @@
+/* { dg-do run } */
+/* { dg-require-effective-target arm_mve_hw } */
+/* { dg-options "-O2" } */
+/* { dg-add-options arm_v8_1m_mve } */
+
+#include "pr108177-4.c"
diff --git a/gcc/testsuite/gcc.target/arm/mve/pr108177-4.c b/gcc/testsuite/gcc.target/arm/mve/pr108177-4.c
new file mode 100644
index 0000000..dc4f7dd
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/mve/pr108177-4.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target arm_v8_1m_mve_ok } */
+/* { dg-options "-O2" } */
+/* { dg-add-options arm_v8_1m_mve } */
+/* { dg-final { check-function-bodies "**" "" "" } } */
+
+/*
+** test:
+**...
+**	vstrbt.16	q0, \[r0\]
+**...
+**	vstrbt.16	q0, \[r0\]
+**...
+*/
+
+#define TYPE int16x8_t
+#define INTRINSIC vstrbq_s16
+#define INTRINSIC_P vstrbq_p_s16
+
+#include "pr108177.x"
diff --git a/gcc/testsuite/gcc.target/arm/mve/pr108177-5-run.c b/gcc/testsuite/gcc.target/arm/mve/pr108177-5-run.c
new file mode 100644
index 0000000..7211828
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/mve/pr108177-5-run.c
@@ -0,0 +1,6 @@
+/* { dg-do run } */
+/* { dg-require-effective-target arm_mve_hw } */
+/* { dg-options "-O2" } */
+/* { dg-add-options arm_v8_1m_mve } */
+
+#include "pr108177-5.c"
diff --git a/gcc/testsuite/gcc.target/arm/mve/pr108177-5.c b/gcc/testsuite/gcc.target/arm/mve/pr108177-5.c
new file mode 100644
index 0000000..d1dfd32
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/mve/pr108177-5.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target arm_v8_1m_mve_ok } */
+/* { dg-options "-O2" } */
+/* { dg-add-options arm_v8_1m_mve } */
+/* { dg-final { check-function-bodies "**" "" "" } } */
+
+/*
+** test:
+**...
+**	vstrbt.32	q0, \[r0\]
+**...
+**	vstrbt.32	q0, \[r0\]
+**...
+*/
+
+#define TYPE uint32x4_t
+#define INTRINSIC vstrbq_u32
+#define INTRINSIC_P vstrbq_p_u32
+
+#include "pr108177.x"
diff --git a/gcc/testsuite/gcc.target/arm/mve/pr108177-6-run.c b/gcc/testsuite/gcc.target/arm/mve/pr108177-6-run.c
new file mode 100644
index 0000000..4e7d108
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/mve/pr108177-6-run.c
@@ -0,0 +1,6 @@
+/* { dg-do run } */
+/* { dg-require-effective-target arm_mve_hw } */
+/* { dg-options "-O2" } */
+/* { dg-add-options arm_v8_1m_mve } */
+
+#include "pr108177-6.c"
diff --git a/gcc/testsuite/gcc.target/arm/mve/pr108177-6.c b/gcc/testsuite/gcc.target/arm/mve/pr108177-6.c
new file mode 100644
index 0000000..fa70dde
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/mve/pr108177-6.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target arm_v8_1m_mve_ok } */
+/* { dg-options "-O2" } */
+/* { dg-add-options arm_v8_1m_mve } */
+/* { dg-final { check-function-bodies "**" "" "" } } */
+
+/*
+** test:
+**...
+**	vstrbt.32	q0, \[r0\]
+**...
+**	vstrbt.32	q0, \[r0\]
+**...
+*/
+
+#define TYPE int32x4_t
+#define INTRINSIC vstrbq_s32
+#define INTRINSIC_P vstrbq_p_s32
+
+#include "pr108177.x"
diff --git a/gcc/testsuite/gcc.target/arm/mve/pr108177-7-run.c b/gcc/testsuite/gcc.target/arm/mve/pr108177-7-run.c
new file mode 100644
index 0000000..94c492e
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/mve/pr108177-7-run.c
@@ -0,0 +1,6 @@
+/* { dg-do run } */
+/* { dg-require-effective-target arm_mve_hw } */
+/* { dg-options "-O2" } */
+/* { dg-add-options arm_v8_1m_mve } */
+
+#include "pr108177-7.c"
diff --git a/gcc/testsuite/gcc.target/arm/mve/pr108177-7.c b/gcc/testsuite/gcc.target/arm/mve/pr108177-7.c
new file mode 100644
index 0000000..73cd860
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/mve/pr108177-7.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target arm_v8_1m_mve_ok } */
+/* { dg-options "-O2" } */
+/* { dg-add-options arm_v8_1m_mve } */
+/* { dg-final { check-function-bodies "**" "" "" } } */
+
+/*
+** test:
+**...
+**	vstrht.16	q0, \[r0\]
+**...
+**	vstrht.16	q0, \[r0\]
+**...
+*/
+
+#define TYPE uint16x8_t
+#define INTRINSIC vstrhq_u16
+#define INTRINSIC_P vstrhq_p_u16
+
+#include "pr108177.x"
diff --git a/gcc/testsuite/gcc.target/arm/mve/pr108177-8-run.c b/gcc/testsuite/gcc.target/arm/mve/pr108177-8-run.c
new file mode 100644
index 0000000..3c34045
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/mve/pr108177-8-run.c
@@ -0,0 +1,6 @@
+/* { dg-do run } */
+/* { dg-require-effective-target arm_mve_hw } */
+/* { dg-options "-O2" } */
+/* { dg-add-options arm_v8_1m_mve } */
+
+#include "pr108177-8.c"
diff --git a/gcc/testsuite/gcc.target/arm/mve/pr108177-8.c b/gcc/testsuite/gcc.target/arm/mve/pr108177-8.c
new file mode 100644
index 0000000..187c2b3
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/mve/pr108177-8.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target arm_v8_1m_mve_ok } */
+/* { dg-options "-O2" } */
+/* { dg-add-options arm_v8_1m_mve } */
+/* { dg-final { check-function-bodies "**" "" "" } } */
+
+/*
+** test:
+**...
+**	vstrht.16	q0, \[r0\]
+**...
+**	vstrht.16	q0, \[r0\]
+**...
+*/
+
+#define TYPE int16x8_t
+#define INTRINSIC vstrhq_s16
+#define INTRINSIC_P vstrhq_p_s16
+
+#include "pr108177.x"
diff --git a/gcc/testsuite/gcc.target/arm/mve/pr108177-9-run.c b/gcc/testsuite/gcc.target/arm/mve/pr108177-9-run.c
new file mode 100644
index 0000000..967cf7f
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/mve/pr108177-9-run.c
@@ -0,0 +1,6 @@
+/* { dg-do run } */
+/* { dg-require-effective-target arm_mve_hw } */
+/* { dg-options "-O2" } */
+/* { dg-add-options arm_v8_1m_mve } */
+
+#include "pr108177-9.c"
diff --git a/gcc/testsuite/gcc.target/arm/mve/pr108177-9.c b/gcc/testsuite/gcc.target/arm/mve/pr108177-9.c
new file mode 100644
index 0000000..caecd18
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/mve/pr108177-9.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target arm_v8_1m_mve_ok } */
+/* { dg-options "-O2" } */
+/* { dg-add-options arm_v8_1m_mve } */
+/* { dg-final { check-function-bodies "**" "" "" } } */
+
+/*
+** test:
+**...
+**	vstrht.32	q0, \[r0\]
+**...
+**	vstrht.32	q0, \[r0\]
+**...
+*/
+
+#define TYPE uint32x4_t
+#define INTRINSIC vstrhq_u32
+#define INTRINSIC_P vstrhq_p_u32
+
+#include "pr108177.x"
diff --git a/gcc/testsuite/gcc.target/arm/mve/pr108177-main.x b/gcc/testsuite/gcc.target/arm/mve/pr108177-main.x
new file mode 100644
index 0000000..f5f965f
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/mve/pr108177-main.x
@@ -0,0 +1,31 @@
+#include <arm_mve.h>
+extern void abort (void);
+
+__attribute__ ((noipa)) void
+write_expected (uint32x4_t v, void *a)
+{
+  TYPE _v = (TYPE) v;
+  INTRINSIC (a, _v);
+}
+
+void test (uint32x4_t, void *, mve_pred16_t, mve_pred16_t);
+
+int main(void)
+{
+  uint32x4_t v = {0, 1, 2, 3};
+  uint32_t actual[] = {0, 0, 0, 0};
+  uint32_t expected[] = {0, 0, 0, 0};
+
+  write_expected (v, &(expected[0]));
+
+  mve_pred16_t p1 = 0xff00;
+  mve_pred16_t p2 = 0x00ff;
+
+  test (v, (void *)&actual[0], p1, p2);
+
+  if (__builtin_memcmp (&actual[0], &expected[0], 16) != 0)
+    abort ();
+
+  return 0;
+}
+
diff --git a/gcc/testsuite/gcc.target/arm/mve/pr108177.x b/gcc/testsuite/gcc.target/arm/mve/pr108177.x
new file mode 100644
index 0000000..019ef54
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/mve/pr108177.x
@@ -0,0 +1,9 @@
+#include "pr108177-main.x"
+
+__attribute__ ((noipa)) void
+test (uint32x4_t v, void *a, mve_pred16_t p1, mve_pred16_t p2)
+{
+  TYPE _v = (TYPE) v;
+  INTRINSIC_P (a, _v, p1);
+  INTRINSIC_P (a, _v, p2);
+}
diff --git a/gcc/testsuite/gcc.target/arm/pac-1.c b/gcc/testsuite/gcc.target/arm/pac-1.c
new file mode 100644
index 0000000..9b26f62
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/pac-1.c
@@ -0,0 +1,11 @@
+/* Testing return address signing.  */
+/* { dg-do run } */
+/* { dg-require-effective-target mbranch_protection_ok } */
+/* { dg-require-effective-target arm_pacbti_hw } */
+/* { dg-options "-march=armv8.1-m.main+pacbti+fp -mbranch-protection=pac-ret+leaf -mthumb -mfloat-abi=hard --save-temps -O0" } */
+
+#include "pac.h"
+
+/* { dg-final { scan-assembler-times "pac\tip, lr, sp" 2 } } */
+/* { dg-final { scan-assembler-times "aut\tip, lr, sp" 2 } } */
+/* { dg-final { scan-assembler-not "\tbti" } } */
diff --git a/gcc/testsuite/gcc.target/arm/pac-10.c b/gcc/testsuite/gcc.target/arm/pac-10.c
new file mode 100644
index 0000000..a794195
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/pac-10.c
@@ -0,0 +1,10 @@
+/* Testing return address signing.  */
+/* { dg-do compile } */
+/* { dg-require-effective-target mbranch_protection_ok } */
+/* { dg-options "-march=armv8.1-m.main+pacbti+fp -mbranch-protection=pac-ret -mthumb -mfloat-abi=hard --save-temps -O0" } */
+
+#include "pac.h"
+
+/* { dg-final { scan-assembler "pac\tip, lr, sp" } } */
+/* { dg-final { scan-assembler "aut\tip, lr, sp" } } */
+/* { dg-final { scan-assembler-not "\tbti" } } */
diff --git a/gcc/testsuite/gcc.target/arm/pac-11.c b/gcc/testsuite/gcc.target/arm/pac-11.c
new file mode 100644
index 0000000..37ffc93
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/pac-11.c
@@ -0,0 +1,10 @@
+/* Testing return address signing.  */
+/* { dg-do compile } */
+/* { dg-require-effective-target mbranch_protection_ok } */
+/* { dg-options "-march=armv8.1-m.main+pacbti+fp -mbranch-protection=bti+pac-ret+leaf -mthumb -mfloat-abi=hard --save-temps -O2" } */
+
+#include "pac.h"
+
+/* { dg-final { scan-assembler-times "pacbti\tip, lr, sp" 2 } } */
+/* { dg-final { scan-assembler-times "aut\tip, lr, sp" 2 } } */
+/* { dg-final { scan-assembler-not "\tbti" } } */
diff --git a/gcc/testsuite/gcc.target/arm/pac-12.c b/gcc/testsuite/gcc.target/arm/pac-12.c
new file mode 100644
index 0000000..6e1295c
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/pac-12.c
@@ -0,0 +1,7 @@
+/* Testing PACBTI multilibs matches without mve.  */
+/* { dg-do run } */
+/* { dg-require-effective-target arm_pacbti_hw } */
+/* { dg-skip-if "need fp instructions" { *-*-* } { "" } { "-mfloat-abi=hard" } } */
+/* { dg-options "-march=armv8.1-m.main+dsp+fp.dp+pacbti -mbranch-protection=standard -mthumb -mfloat-abi=hard" } */
+
+#include "pac.h"
diff --git a/gcc/testsuite/gcc.target/arm/pac-13.c b/gcc/testsuite/gcc.target/arm/pac-13.c
new file mode 100644
index 0000000..faf836b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/pac-13.c
@@ -0,0 +1,7 @@
+/* Testing PACBTI multilib matches.  */
+/* { dg-do run } */
+/* { dg-require-effective-target arm_pacbti_hw } */
+/* { dg-skip-if "need fp instructions" { *-*-* } { "" } { "-mfloat-abi=hard" } } */
+/* { dg-options "-march=armv8.1-m.main+mve.fp+fp.dp+pacbti -mbranch-protection=standard -mthumb -mfloat-abi=hard" } */
+
+#include "pac.h"
diff --git a/gcc/testsuite/gcc.target/arm/pac-14.c b/gcc/testsuite/gcc.target/arm/pac-14.c
new file mode 100644
index 0000000..51609b6
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/pac-14.c
@@ -0,0 +1,7 @@
+/* Testing PACBTI multilibs matches without mve float.  */
+/* { dg-do run } */
+/* { dg-require-effective-target arm_pacbti_hw } */
+/* { dg-skip-if "need fp instructions" { *-*-* } { "" } { "-mfloat-abi=hard" } } */
+/* { dg-options "-march=armv8.1-m.main+mve+fp.dp+pacbti -mbranch-protection=standard -mthumb -mfloat-abi=hard" } */
+
+#include "pac.h"
diff --git a/gcc/testsuite/gcc.target/arm/pac-15.c b/gcc/testsuite/gcc.target/arm/pac-15.c
new file mode 100644
index 0000000..e105490
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/pac-15.c
@@ -0,0 +1,32 @@
+/* Check that GCC does .save and .cfi_offset directives with RA_AUTH_CODE pseudo hard-register.  */
+/* { dg-do compile } */
+/* { dg-require-effective-target mbranch_protection_ok } */
+/* { dg-skip-if "avoid conflicting multilib options" { *-*-* } { "-marm" "-mcpu=*" } } */
+/* { dg-options "-march=armv8.1-m.main+mve+pacbti -mbranch-protection=pac-ret -mthumb -mfloat-abi=hard -fasynchronous-unwind-tables -g -O0" } */
+
+#include "stdio.h"
+
+__attribute__((noinline)) int
+fn1 (int a)
+{
+  const char *fmt = "branch-protection";
+  int fun1(int x,const char *fmt,int c,int d)
+    {
+      printf("string = %s\n",fmt);
+      return x+c+d;
+    }
+  return fun1(a,fmt,10,10);
+}
+
+int main (void)
+{
+  return fn1 (40);
+}
+
+/* { dg-final { scan-assembler-times "\.pacspval" 1 } } */
+/* { dg-final { scan-assembler-times "pac	ip, lr, sp" 3 } } */
+/* { dg-final { scan-assembler-times "\.cfi_register 143, 12" 3 } } */
+/* { dg-final { scan-assembler-times "\.save {r7, ra_auth_code, lr}" 2 } } */
+/* { dg-final { scan-assembler-times "\.cfi_offset 143, -8" 2 } } */
+/* { dg-final { scan-assembler-times "\.save {r3, r7, ra_auth_code, lr}" 1 } } */
+/* { dg-final { scan-assembler-times "\.cfi_offset 143, -12" 1 } } */
diff --git a/gcc/testsuite/gcc.target/arm/pac-2.c b/gcc/testsuite/gcc.target/arm/pac-2.c
new file mode 100644
index 0000000..945ce93
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/pac-2.c
@@ -0,0 +1,11 @@
+/* Testing return address signing.  */
+/* { dg-do run } */
+/* { dg-require-effective-target mbranch_protection_ok } */
+/* { dg-require-effective-target arm_pacbti_hw } */
+/* { dg-options "-march=armv8.1-m.main+pacbti+fp -mbranch-protection=pac-ret -mthumb -mfloat-abi=hard --save-temps -O0" } */
+
+#include "pac.h"
+
+/* { dg-final { scan-assembler "pac\tip, lr, sp" } } */
+/* { dg-final { scan-assembler "aut\tip, lr, sp" } } */
+/* { dg-final { scan-assembler-not "\tbti" } } */
diff --git a/gcc/testsuite/gcc.target/arm/pac-3.c b/gcc/testsuite/gcc.target/arm/pac-3.c
new file mode 100644
index 0000000..47e290a
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/pac-3.c
@@ -0,0 +1,11 @@
+/* Testing return address signing.  */
+/* { dg-do run } */
+/* { dg-require-effective-target mbranch_protection_ok } */
+/* { dg-require-effective-target arm_pacbti_hw } */
+/* { dg-options "-march=armv8.1-m.main+pacbti+fp -mbranch-protection=bti+pac-ret+leaf -mthumb -mfloat-abi=hard --save-temps -O2" } */
+
+#include "pac.h"
+
+/* { dg-final { scan-assembler-times "pacbti\tip, lr, sp" 2 } } */
+/* { dg-final { scan-assembler-times "aut\tip, lr, sp" 2 } } */
+/* { dg-final { scan-assembler-not "\tbti" } } */
diff --git a/gcc/testsuite/gcc.target/arm/pac-4.c b/gcc/testsuite/gcc.target/arm/pac-4.c
new file mode 100644
index 0000000..cf915cd
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/pac-4.c
@@ -0,0 +1,10 @@
+/* Testing return address signing.  */
+/* { dg-do compile } */
+/* { dg-require-effective-target mbranch_protection_ok } */
+/* { dg-options "-march=armv8.1-m.main+pacbti+fp -mthumb -mfloat-abi=hard --save-temps -O2" } */
+
+#include "pac.h"
+
+/* { dg-final { scan-assembler-not "\tbti\t" } } */
+/* { dg-final { scan-assembler-not "\tpac\t" } } */
+/* { dg-final { scan-assembler-not "\tpacbti\t" } } */
diff --git a/gcc/testsuite/gcc.target/arm/pac-5.c b/gcc/testsuite/gcc.target/arm/pac-5.c
new file mode 100644
index 0000000..c70087e
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/pac-5.c
@@ -0,0 +1,28 @@
+/* Testing return address signing.  */
+/* { dg-do run } */
+/* { dg-require-effective-target mbranch_protection_ok } */
+/* { dg-require-effective-target arm_pacbti_hw } */
+/* { dg-options "-march=armv8.1-m.main+pacbti+fp -mbranch-protection=pac-ret+leaf -mthumb -mfloat-abi=hard --save-temps -O0" } */
+
+#include <stdlib.h>
+
+int
+__attribute__((noinline))
+foo1 (int a, int b)
+{
+  int square (int z) { return z * z; }
+  return square (a) + square (b);
+}
+
+int
+main (void)
+{
+  if (foo1 (1, 2) != 5)
+    abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-assembler-times "pac\tip, lr, sp" 3 } } */
+/* { dg-final { scan-assembler-times "aut\tip, lr, sp" 3 } } */
+/* { dg-final { scan-assembler-not "\tbti" } } */
diff --git a/gcc/testsuite/gcc.target/arm/pac-6.c b/gcc/testsuite/gcc.target/arm/pac-6.c
new file mode 100644
index 0000000..c5329f0
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/pac-6.c
@@ -0,0 +1,18 @@
+/* Check that GCC does .save and .cfi_offset directives with RA_AUTH_CODE pseudo hard-register.  */
+/* { dg-do compile } */
+/* { dg-require-effective-target mbranch_protection_ok } */
+/* { dg-options "-march=armv8.1-m.main+fp -mbranch-protection=pac-ret+leaf -mthumb --save-temps -O0 -g" } */
+
+int i;
+
+void foo (int);
+
+int bar()
+{
+  foo (i);
+  return 0;
+}
+
+/* { dg-final { scan-assembler "pac\tip, lr, sp" } } */
+/* { dg-final { scan-assembler "aut\tip, lr, sp" } } */
+/* { dg-final { scan-assembler-not "bti" } } */
diff --git a/gcc/testsuite/gcc.target/arm/pac-7.c b/gcc/testsuite/gcc.target/arm/pac-7.c
new file mode 100644
index 0000000..cdaebca
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/pac-7.c
@@ -0,0 +1,32 @@
+/* Testing return address signing.  */
+/* { dg-do run } */
+/* { dg-require-effective-target mbranch_protection_ok } */
+/* { dg-require-effective-target arm_pacbti_hw } */
+/* { dg-options "-march=armv8.1-m.main+pacbti+fp -mbranch-protection=pac-ret+leaf -mthumb -mfloat-abi=hard --save-temps -O0" } */
+
+#include <stdlib.h>
+
+int
+__attribute__((noinline))
+foo1 (int a, int b)
+{
+  int x = 4;
+  int foo2 (int a, int b)
+  {
+    return a + b + x;
+  }
+  return foo2 (a, b);
+}
+
+int
+main (void)
+{
+  if (foo1 (1, 2) != 7)
+    abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-assembler-times "pac\tip, lr, sp" 3 } } */
+/* { dg-final { scan-assembler-times "aut\tip, lr, sp" 3 } } */
+/* { dg-final { scan-assembler-not "\tbti" } } */
diff --git a/gcc/testsuite/gcc.target/arm/pac-8.c b/gcc/testsuite/gcc.target/arm/pac-8.c
new file mode 100644
index 0000000..3f37dcf
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/pac-8.c
@@ -0,0 +1,34 @@
+/* Testing return address signing.  */
+/* { dg-do run } */
+/* { dg-require-effective-target mbranch_protection_ok } */
+/* { dg-require-effective-target arm_pacbti_hw } */
+/* { dg-options "-march=armv8.1-m.main+pacbti+fp -mbranch-protection=pac-ret+leaf -mthumb -mfloat-abi=hard --save-temps -O0" } */
+
+#include <stdarg.h>
+#include <stdlib.h>
+
+int acc (int n, ...)
+{
+    int sum = 0;
+    va_list ptr;
+
+    va_start (ptr, n);
+
+    for (int i = 0; i < n; i++)
+        sum += va_arg (ptr, int);
+    va_end (ptr);
+
+    return sum;
+}
+
+int main()
+{
+  if (acc (3, 1, 2, 3) != 6)
+    abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-assembler-times "pac\tip, lr, sp" 2 } } */
+/* { dg-final { scan-assembler-times "aut\tip, lr, sp" 2 } } */
+/* { dg-final { scan-assembler-not "\tbti" } } */
diff --git a/gcc/testsuite/gcc.target/arm/pac-9.c b/gcc/testsuite/gcc.target/arm/pac-9.c
new file mode 100644
index 0000000..ee2fad2
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/pac-9.c
@@ -0,0 +1,11 @@
+/* Testing return address signing.  */
+/* { dg-do compile } */
+/* { dg-require-effective-target mbranch_protection_ok } */
+/* { dg-options "-march=armv8.1-m.main+pacbti+fp -mbranch-protection=pac-ret+leaf -mthumb -mfloat-abi=hard --save-temps -O0" } */
+
+#include "pac.h"
+
+/* { dg-final { scan-assembler-times "pac\tip, lr, sp" 2 } } */
+/* { dg-final { scan-assembler-times "aut\tip, lr, sp" 2 } } */
+/* { dg-final { scan-assembler-not "\tbti" } } */
+
diff --git a/gcc/testsuite/gcc.target/arm/pac.h b/gcc/testsuite/gcc.target/arm/pac.h
new file mode 100644
index 0000000..7355e6b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/pac.h
@@ -0,0 +1,17 @@
+#include <stdlib.h>
+
+int
+__attribute__((noinline))
+foo1 (int a, int b)
+{
+  return a + b;
+}
+
+int
+main (void)
+{
+  if (foo1 (1, 2) != 3)
+    abort ();
+
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.target/arm/simd/mve-vclz.c b/gcc/testsuite/gcc.target/arm/simd/mve-vclz.c
index 7068736..38e91fc 100644
--- a/gcc/testsuite/gcc.target/arm/simd/mve-vclz.c
+++ b/gcc/testsuite/gcc.target/arm/simd/mve-vclz.c
@@ -23,6 +23,6 @@ FUNC(u, uint, 8, clz)
 
 /* 16 and 8-bit versions are not vectorized because they need pack/unpack
    patterns since __builtin_clz uses 32-bit parameter and return value.  */
-/* { dg-final { scan-assembler-times {vclz\.i32  q[0-9]+, q[0-9]+} 2 } } */
-/* { dg-final { scan-assembler-times {vclz\.i16  q[0-9]+, q[0-9]+} 2 { xfail *-*-* } } } */
-/* { dg-final { scan-assembler-times {vclz\.i8  q[0-9]+, q[0-9]+} 2 { xfail *-*-* } } } */
+/* { dg-final { scan-assembler-times {vclz\.i32\tq[0-9]+, q[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vclz\.i16\tq[0-9]+, q[0-9]+} 2 { xfail *-*-* } } } */
+/* { dg-final { scan-assembler-times {vclz\.i8\tq[0-9]+, q[0-9]+} 2 { xfail *-*-* } } } */
diff --git a/gcc/testsuite/gcc.target/arm/simd/mve-vneg.c b/gcc/testsuite/gcc.target/arm/simd/mve-vneg.c
index 7945a06..1379cae 100644
--- a/gcc/testsuite/gcc.target/arm/simd/mve-vneg.c
+++ b/gcc/testsuite/gcc.target/arm/simd/mve-vneg.c
@@ -45,8 +45,8 @@ FUNC(f, float, 16, 8, -, vneg)
 
 /* MVE has only 128-bit vectors, so we can vectorize only half of the
    functions above.  */
-/* { dg-final { scan-assembler-times {vneg.s[0-9]+  q[0-9]+, q[0-9]+} 6 } } */
-/* { dg-final { scan-assembler-times {vneg.f[0-9]+  q[0-9]+, q[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vneg.s[0-9]+\tq[0-9]+, q[0-9]+} 6 } } */
+/* { dg-final { scan-assembler-times {vneg.f[0-9]+\tq[0-9]+, q[0-9]+} 2 } } */
 /* { dg-final { scan-assembler-times {vldr[bhw].[0-9]+\tq[0-9]+} 8 } } */
 /* { dg-final { scan-assembler-times {vstr[bhw].[0-9]+\tq[0-9]+} 8 } } */
 /* { dg-final { scan-assembler-not {orr\tr[0-9]+, r[0-9]+, r[0-9]+} } } */
diff --git a/gcc/testsuite/gcc.target/arm/simd/mve-vshr.c b/gcc/testsuite/gcc.target/arm/simd/mve-vshr.c
index d4258e9..8c7adef 100644
--- a/gcc/testsuite/gcc.target/arm/simd/mve-vshr.c
+++ b/gcc/testsuite/gcc.target/arm/simd/mve-vshr.c
@@ -58,7 +58,7 @@ FUNC_IMM(u, uint, 8, 16, >>, vshrimm)
 /* Vector right shifts use vneg and left shifts.  */
 /* { dg-final { scan-assembler-times {vshl.s[0-9]+\tq[0-9]+, q[0-9]+} 3 } } */
 /* { dg-final { scan-assembler-times {vshl.u[0-9]+\tq[0-9]+, q[0-9]+} 3 } } */
-/* { dg-final { scan-assembler-times {vneg.s[0-9]+  q[0-9]+, q[0-9]+} 6 } } */
+/* { dg-final { scan-assembler-times {vneg.s[0-9]+\tq[0-9]+, q[0-9]+} 6 } } */
 
 
 /* Shift by immediate.  */
diff --git a/gcc/testsuite/gcc.target/i386/avx2-pr108599.c b/gcc/testsuite/gcc.target/i386/avx2-pr108599.c
new file mode 100644
index 0000000..d5ddab7
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/avx2-pr108599.c
@@ -0,0 +1,32 @@
+/* PR target/108599 */
+/* { dg-do run { target avx2 } } */
+/* { dg-options "-O2 -mavx2 -mtune=skylake-avx512" } */
+
+#include "avx2-check.h"
+
+struct S { unsigned long long a, b, c, d; };
+
+__attribute__((noipa)) void
+foo (unsigned long long x, unsigned long long y,
+     unsigned long long z, unsigned long long w, const struct S s)
+{
+  if (s.a != x || s.b != y || s.c != z || s.d != w)
+    abort ();
+}
+
+typedef unsigned long long V __attribute__((may_alias, vector_size (4 * sizeof (unsigned long long))));
+
+static void
+avx2_test (void)
+{
+  {
+    struct S s;
+    *(V *)&s = (V) { 16, 0, 0, 0 };
+    foo (16, 0, 0, 0, s);
+  }
+  {
+    struct S s;
+    *(V *)&s = (V) { 16, 16, 0, 0 };
+    foo (16, 16, 0, 0, s);
+  }
+}
diff --git a/gcc/testsuite/gcc.target/i386/pr106746.c b/gcc/testsuite/gcc.target/i386/pr106746.c
new file mode 100644
index 0000000..14f7dab
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr106746.c
@@ -0,0 +1,29 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fsched2-use-superblocks -fcompare-debug -Wno-psabi" } */
+
+typedef char __attribute__((__vector_size__ (64))) U;
+typedef short __attribute__((__vector_size__ (64))) V;
+typedef int __attribute__((__vector_size__ (64))) W;
+
+char c;
+U a;
+U *r;
+W foo0_v512u32_0;
+
+void
+foo (W)
+{
+  U u;
+  V v;
+  W w = __builtin_shuffle (foo0_v512u32_0, foo0_v512u32_0);
+  u =
+    __builtin_shufflevector (a, u, 3, 0, 4, 9, 9, 6, 7, 8, 5,
+			     0, 6, 1, 8, 1, 2, 8, 6,
+			     1, 8, 4, 9, 3, 8, 4, 6, 0, 9, 0, 1, 8, 2, 3, 3,
+			     0, 4, 9, 9, 6, 7, 8, 5,
+			     0, 6, 1, 8, 1, 2, 8, 6,
+			     1, 8, 4, 9, 3, 8, 4, 6, 0, 9, 0, 1, 8, 2, 3);
+  v *= c;
+  w &= c;
+  *r = (U) v + (U) w;
+}
diff --git a/gcc/testsuite/gcc.target/i386/pr108436.c b/gcc/testsuite/gcc.target/i386/pr108436.c
new file mode 100644
index 0000000..d51f258
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr108436.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-mprefetchi" } */
+
+int
+foo (int a)
+{
+  return a + 1;
+}
+
+void
+bad (int *p)
+{
+  __builtin_ia32_prefetch (p, 0, 4, 0);   /* { dg-warning "invalid third argument to '__builtin_ia32_prefetch'; using zero" } */
+  __builtin_ia32_prefetch (foo, 0, 4, 1);   /* { dg-error "invalid third argument" } */
+}
diff --git a/gcc/testsuite/gcc.target/i386/sse-23.c b/gcc/testsuite/gcc.target/i386/sse-23.c
index 0f56e93..37cc2fd 100644
--- a/gcc/testsuite/gcc.target/i386/sse-23.c
+++ b/gcc/testsuite/gcc.target/i386/sse-23.c
@@ -1,5 +1,5 @@
 /* { dg-do compile } */
-/* { dg-options "-O2 -Werror-implicit-function-declaration -march=k8" } */
+/* { dg-options "-O2 -Werror-implicit-function-declaration -Wuninitialized -march=k8" } */
 /* { dg-add-options bind_pic_locally } */
 
 #include <mm_malloc.h>
diff --git a/gcc/testsuite/gcc.target/loongarch/tst-asm-const.c b/gcc/testsuite/gcc.target/loongarch/pr107731.c
index 2e04b99..80d84c4 100644
--- a/gcc/testsuite/gcc.target/loongarch/tst-asm-const.c
+++ b/gcc/testsuite/gcc.target/loongarch/pr107731.c
@@ -1,13 +1,13 @@
-/* Test asm const. */
 /* { dg-do compile } */
 /* { dg-final { scan-assembler-times "foo:.*\\.long 1061109567.*\\.long 52" 1 } } */
+
 int foo ()
 {
   __asm__ volatile (
           "foo:"
           "\n\t"
-	  ".long %a0\n\t"
-	  ".long %a1\n\t"
+	  ".long %c0\n\t"
+	  ".long %c1\n\t"
 	  :
 	  :"i"(0x3f3f3f3f), "i"(52)
 	  :
diff --git a/gcc/testsuite/gcc.target/pdp11/pdp11.exp b/gcc/testsuite/gcc.target/pdp11/pdp11.exp
new file mode 100644
index 0000000..89b1f25
--- /dev/null
+++ b/gcc/testsuite/gcc.target/pdp11/pdp11.exp
@@ -0,0 +1,41 @@
+# Copyright (C) 2023 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with GCC; see the file COPYING3.  If not see
+# <http://www.gnu.org/licenses/>.
+
+# GCC testsuite that uses the `dg.exp' driver.
+
+# Exit immediately if this isn't an pdp11 target.
+if ![istarget pdp11*-*-*] then {
+  return
+}
+
+# Load support procs.
+load_lib gcc-dg.exp
+
+# If a testcase doesn't have special options, use these.
+global DEFAULT_CFLAGS
+if ![info exists DEFAULT_CFLAGS] then {
+    set DEFAULT_CFLAGS " -ansi -pedantic-errors"
+}
+
+# Initialize `dg'.
+dg-init
+
+# Main loop.
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/*.\[cS\]]] \
+	"" $DEFAULT_CFLAGS
+
+# All done.
+dg-finish
diff --git a/gcc/testsuite/gcc.target/pdp11/pr108388.c b/gcc/testsuite/gcc.target/pdp11/pr108388.c
new file mode 100644
index 0000000..0d54b91
--- /dev/null
+++ b/gcc/testsuite/gcc.target/pdp11/pr108388.c
@@ -0,0 +1,90 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -mlra" } */
+
+typedef int SItype __attribute__ ((mode (SI)));
+typedef unsigned int USItype __attribute__ ((mode (SI)));
+typedef int DItype __attribute__ ((mode (DI)));
+typedef unsigned int UDItype __attribute__ ((mode (DI)));
+extern DItype __mulvdi3 (DItype, DItype);
+struct DWstruct {SItype high, low;};
+
+typedef union {
+  struct DWstruct s;
+  DItype ll;
+} DWunion;
+
+DItype __mulvdi3 (DItype u, DItype v) {
+  const DWunion uu = {.ll = u};
+  const DWunion vv = {.ll = v};
+  
+  if (__builtin_expect (uu.s.high == uu.s.low >> ((4 * 8) - 1), 1)) {
+    if (__builtin_expect (vv.s.high == vv.s.low >> ((4 * 8) - 1), 1)) {
+      return (DItype) uu.s.low * (DItype) vv.s.low;
+    } else {
+      DWunion w0 = {.ll = (UDItype) (USItype) uu.s.low * (UDItype) (USItype) vv.s.low};
+      DWunion w1 = {.ll = (UDItype) (USItype) uu.s.low * (UDItype) (USItype) vv.s.high};
+      
+      if (vv.s.high < 0)
+	w1.s.high -= uu.s.low;
+      if (uu.s.low < 0)
+	w1.ll -= vv.ll;
+      w1.ll += (USItype) w0.s.high;
+      if (__builtin_expect (w1.s.high == w1.s.low >> ((4 * 8) - 1), 1))	{
+	w0.s.high = w1.s.low;
+	return w0.ll;
+      }
+    }
+  } else {
+    if (__builtin_expect (vv.s.high == vv.s.low >> ((4 * 8) - 1), 1)) {
+      DWunion w0 = {.ll = (UDItype) (USItype) uu.s.low * (UDItype) (USItype) vv.s.low};
+      DWunion w1 = {.ll = (UDItype) (USItype) uu.s.high * (UDItype) (USItype) vv.s.low};
+
+      if (uu.s.high < 0)
+	w1.s.high -= vv.s.low;
+      if (vv.s.low < 0)
+	w1.ll -= uu.ll;
+      w1.ll += (USItype) w0.s.high;
+      if (__builtin_expect (w1.s.high == w1.s.low >> ((4 * 8) - 1), 1))	{
+	w0.s.high = w1.s.low;
+	return w0.ll;
+      }
+    } else {
+      if (uu.s.high >= 0) {
+	if (vv.s.high >= 0) {
+	  if (uu.s.high == 0 && vv.s.high == 0) {
+	    const DItype w = (UDItype) (USItype) uu.s.low * (UDItype) (USItype) vv.s.low;
+	    if (__builtin_expect (w >= 0, 1))
+	      return w;
+	  }
+	} else {
+	  if (uu.s.high == 0 && vv.s.high == (SItype) -1) {
+	    DWunion ww = {.ll = (UDItype) (USItype) uu.s.low * (UDItype) (USItype) vv.s.low};
+	    ww.s.high -= uu.s.low;
+	    if (__builtin_expect (ww.s.high < 0, 1))
+	      return ww.ll;
+	  }
+	}
+      } else {
+	if (vv.s.high >= 0) {
+	  if (uu.s.high == (SItype) -1 && vv.s.high == 0) {
+	    DWunion ww = {.ll = (UDItype) (USItype) uu.s.low * (UDItype) (USItype) vv.s.low};
+	    
+	    ww.s.high -= vv.s.low;
+	    if (__builtin_expect (ww.s.high < 0, 1))
+	      return ww.ll;
+	  }
+	} else {
+	  if ((uu.s.high & vv.s.high) == (SItype) -1 && (uu.s.low | vv.s.low) != 0) {
+	      DWunion ww = {.ll = (UDItype) (USItype) uu.s.low * (UDItype) (USItype) vv.s.low};
+	      
+	      ww.s.high -= uu.s.low;
+	      ww.s.high -= vv.s.low;
+	      if (__builtin_expect (ww.s.high >= 0, 1))
+		return ww.ll;
+	  }
+	}
+      }
+    }
+  }
+  __builtin_trap ();
+}
diff --git a/gcc/testsuite/gcc.target/powerpc/pr108348-1.c b/gcc/testsuite/gcc.target/powerpc/pr108348-1.c
new file mode 100644
index 0000000..29cbe7a
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/pr108348-1.c
@@ -0,0 +1,23 @@
+/* { dg-require-effective-target powerpc_altivec_ok } */
+/* If the default cpu type is power10 or later, type __vector_quad is
+   supported.  To keep the test point available all the time, this case
+   specifies -mdejagnu-cpu=power9 here.  This needs -mabi=no-altivec
+   to do the copying for pass-by-reference function argument on 32 bit
+   environment.  */
+/* { dg-options "-mdejagnu-cpu=power9 -mabi=no-altivec" } */
+
+/* Verify there is no ICE on 32 bit and don't check the error messages
+   on unsupported type since they could be fragile and are not test
+   points of this case.  */
+
+/* { dg-excess-errors "pr108348-1" } */
+
+extern void bar (__vector_quad v);
+
+void
+foo (void)
+{
+  __vector_quad v;
+  bar (v);
+}
+
diff --git a/gcc/testsuite/gcc.target/powerpc/pr108348-2.c b/gcc/testsuite/gcc.target/powerpc/pr108348-2.c
new file mode 100644
index 0000000..9aa8939
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/pr108348-2.c
@@ -0,0 +1,23 @@
+/* { dg-require-effective-target powerpc_altivec_ok } */
+/* If the default cpu type is power10 or later, type __vector_pair is
+   supported.  To keep the test point available all the time, this case
+   specifies -mdejagnu-cpu=power9 here.  This needs -mabi=no-altivec
+   to do the copying for pass-by-reference function argument on 32 bit
+   environment.  */
+/* { dg-options "-mdejagnu-cpu=power9 -mabi=no-altivec" } */
+
+/* Verify there is no ICE on 32 bit and don't check the error messages
+   on unsupported type since they could be fragile and are not test
+   points of this case.  */
+
+/* { dg-excess-errors "pr108348-2" } */
+
+extern void bar (__vector_pair v);
+
+void
+foo (void)
+{
+  __vector_pair v;
+  bar (v);
+}
+
diff --git a/gcc/testsuite/gcc.target/powerpc/pr108396.c b/gcc/testsuite/gcc.target/powerpc/pr108396.c
new file mode 100644
index 0000000..a783f08
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/pr108396.c
@@ -0,0 +1,14 @@
+/* { dg-require-effective-target powerpc_p8vector_ok } */
+/* { dg-require-effective-target int128 } */
+/* { dg-options "-mdejagnu-cpu=power8" } */
+
+/* Verify there is no error message.  */
+
+#include <altivec.h>
+
+vector unsigned __int128
+vsubcuq (vector unsigned __int128 a, vector unsigned __int128 b)
+{
+  return vec_vsubcuq (a, b);
+}
+
diff --git a/gcc/testsuite/gcc.target/pru/clz-hi-2.c b/gcc/testsuite/gcc.target/pru/clz-hi-2.c
new file mode 100644
index 0000000..af877c7
--- /dev/null
+++ b/gcc/testsuite/gcc.target/pru/clz-hi-2.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fno-tree-ch" } */
+
+/* This test case is based on gcc.dg/tree-ssa/clz-char.c. */
+
+#define PREC (sizeof(short) * 8)
+
+int
+__attribute__ ((noinline, noclone))
+foo (unsigned short b) {
+    int c = 0;
+
+    if (b == 0)
+      return PREC;
+
+    while (!(b & (1 << (PREC - 1)))) {
+	b <<= 1;
+	c++;
+    }
+
+    return c;
+}
+
+/* { dg-final { scan-assembler "lmbd\\tr\[012\]\[0-9\]?.w\[0-2\], r\[012\]\[0-9\]?.w\[0-2\], 1" } } */
diff --git a/gcc/testsuite/gcc.target/pru/clz-hi.c b/gcc/testsuite/gcc.target/pru/clz-hi.c
new file mode 100644
index 0000000..9350913
--- /dev/null
+++ b/gcc/testsuite/gcc.target/pru/clz-hi.c
@@ -0,0 +1,35 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -fno-tree-ch -fdump-tree-optimized" } */
+
+/* This test case is based on gcc.dg/tree-ssa/clz-char.c. */
+
+#define PREC (sizeof(short) * 8)
+
+int
+__attribute__ ((noinline, noclone))
+foo (unsigned short b) {
+    int c = 0;
+
+    if (b == 0)
+      return PREC;
+
+    while (!(b & (1 << (PREC - 1)))) {
+	b <<= 1;
+	c++;
+    }
+
+    return c;
+}
+
+int main()
+{
+  if (foo(0) != PREC)
+    __builtin_abort ();
+  if (foo(1 << (PREC - 1)) != 0)
+    __builtin_abort ();
+  if (foo(35) != PREC - 6)
+    __builtin_abort ();
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "__builtin_clz|\\.CLZ" 1 "optimized" } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vle-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vle-1.c
new file mode 100644
index 0000000..6335e7b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vle-1.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t 
+test___riscv_vle8_v_i8mf8(int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf8(base,vl);
+}
+
+vint8mf4_t 
+test___riscv_vle8_v_i8mf4(int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf4(base,vl);
+}
+
+vint8mf2_t 
+test___riscv_vle8_v_i8mf2(int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf2(base,vl);
+}
+
+vint8m1_t 
+test___riscv_vle8_v_i8m1(int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m1(base,vl);
+}
+
+vint8m2_t 
+test___riscv_vle8_v_i8m2(int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m2(base,vl);
+}
+
+vint8m4_t 
+test___riscv_vle8_v_i8m4(int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m4(base,vl);
+}
+
+vint8m8_t 
+test___riscv_vle8_v_i8m8(int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m8(base,vl);
+}
+
+vuint8mf8_t 
+test___riscv_vle8_v_u8mf8(uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf8(base,vl);
+}
+
+vuint8mf4_t 
+test___riscv_vle8_v_u8mf4(uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf4(base,vl);
+}
+
+vuint8mf2_t 
+test___riscv_vle8_v_u8mf2(uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf2(base,vl);
+}
+
+vuint8m1_t 
+test___riscv_vle8_v_u8m1(uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m1(base,vl);
+}
+
+vuint8m2_t 
+test___riscv_vle8_v_u8m2(uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m2(base,vl);
+}
+
+vuint8m4_t 
+test___riscv_vle8_v_u8m4(uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m4(base,vl);
+}
+
+vuint8m8_t 
+test___riscv_vle8_v_u8m8(uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m8(base,vl);
+}
+
+vint16mf4_t
+test___riscv_vle16_v_i16mf4(int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf4(base,vl);
+}
+
+vint16mf2_t
+test___riscv_vle16_v_i16mf2(int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf2(base,vl);
+}
+
+vint16m1_t
+test___riscv_vle16_v_i16m1(int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m1(base,vl);
+}
+
+vint16m2_t
+test___riscv_vle16_v_i16m2(int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m2(base,vl);
+}
+
+vint16m4_t
+test___riscv_vle16_v_i16m4(int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m4(base,vl);
+}
+
+vint16m8_t
+test___riscv_vle16_v_i16m8(int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m8(base,vl);
+}
+
+vuint16mf4_t
+test___riscv_vle16_v_u16mf4(uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf4(base,vl);
+}
+
+vuint16mf2_t
+test___riscv_vle16_v_u16mf2(uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf2(base,vl);
+}
+
+vuint16m1_t
+test___riscv_vle16_v_u16m1(uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m1(base,vl);
+}
+
+vuint16m2_t
+test___riscv_vle16_v_u16m2(uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m2(base,vl);
+}
+
+vuint16m4_t
+test___riscv_vle16_v_u16m4(uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m4(base,vl);
+}
+
+vuint16m8_t
+test___riscv_vle16_v_u16m8(uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m8(base,vl);
+}
+
+vint32mf2_t
+test___riscv_vle32_v_i32mf2(int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32mf2(base,vl);
+}
+
+vint32m1_t
+test___riscv_vle32_v_i32m1(int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m1(base,vl);
+}
+
+vint32m2_t
+test___riscv_vle32_v_i32m2(int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m2(base,vl);
+}
+
+vint32m4_t
+test___riscv_vle32_v_i32m4(int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m4(base,vl);
+}
+
+vint32m8_t
+test___riscv_vle32_v_i32m8(int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m8(base,vl);
+}
+
+vuint32mf2_t
+test___riscv_vle32_v_u32mf2(uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32mf2(base,vl);
+}
+
+vuint32m1_t
+test___riscv_vle32_v_u32m1(uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m1(base,vl);
+}
+
+vuint32m2_t
+test___riscv_vle32_v_u32m2(uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m2(base,vl);
+}
+
+vuint32m4_t
+test___riscv_vle32_v_u32m4(uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m4(base,vl);
+}
+
+vuint32m8_t
+test___riscv_vle32_v_u32m8(uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m8(base,vl);
+}
+
+vfloat32mf2_t
+test___riscv_vle32_v_f32mf2(float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32mf2(base,vl);
+}
+
+vfloat32m1_t
+test___riscv_vle32_v_f32m1(float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m1(base,vl);
+}
+
+vfloat32m2_t
+test___riscv_vle32_v_f32m2(float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m2(base,vl);
+}
+
+vfloat32m4_t
+test___riscv_vle32_v_f32m4(float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m4(base,vl);
+}
+
+vfloat32m8_t
+test___riscv_vle32_v_f32m8(float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m8(base,vl);
+}
+vint64m1_t
+test___riscv_vle64_v_i64m1(int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m1(base,vl);
+}
+
+vint64m2_t
+test___riscv_vle64_v_i64m2(int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m2(base,vl);
+}
+
+vint64m4_t
+test___riscv_vle64_v_i64m4(int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m4(base,vl);
+}
+
+vint64m8_t
+test___riscv_vle64_v_i64m8(int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m8(base,vl);
+}
+
+vuint64m1_t
+test___riscv_vle64_v_u64m1(uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m1(base,vl);
+}
+
+vuint64m2_t
+test___riscv_vle64_v_u64m2(uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m2(base,vl);
+}
+
+vuint64m4_t
+test___riscv_vle64_v_u64m4(uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m4(base,vl);
+}
+
+vuint64m8_t
+test___riscv_vle64_v_u64m8(uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m8(base,vl);
+}
+
+vfloat64m1_t
+test___riscv_vle64_v_f64m1(double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m1(base,vl);
+}
+
+vfloat64m2_t
+test___riscv_vle64_v_f64m2(double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m2(base,vl);
+}
+
+vfloat64m4_t
+test___riscv_vle64_v_f64m4(double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m4(base,vl);
+}
+
+vfloat64m8_t
+test___riscv_vle64_v_f64m8(double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m8(base,vl);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vle-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vle-2.c
new file mode 100644
index 0000000..f47137b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vle-2.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t 
+test___riscv_vle8_v_i8mf8(int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf8(base,31);
+}
+
+vint8mf4_t 
+test___riscv_vle8_v_i8mf4(int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf4(base,31);
+}
+
+vint8mf2_t 
+test___riscv_vle8_v_i8mf2(int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf2(base,31);
+}
+
+vint8m1_t 
+test___riscv_vle8_v_i8m1(int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m1(base,31);
+}
+
+vint8m2_t 
+test___riscv_vle8_v_i8m2(int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m2(base,31);
+}
+
+vint8m4_t 
+test___riscv_vle8_v_i8m4(int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m4(base,31);
+}
+
+vint8m8_t 
+test___riscv_vle8_v_i8m8(int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m8(base,31);
+}
+
+vuint8mf8_t 
+test___riscv_vle8_v_u8mf8(uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf8(base,31);
+}
+
+vuint8mf4_t 
+test___riscv_vle8_v_u8mf4(uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf4(base,31);
+}
+
+vuint8mf2_t 
+test___riscv_vle8_v_u8mf2(uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf2(base,31);
+}
+
+vuint8m1_t 
+test___riscv_vle8_v_u8m1(uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m1(base,31);
+}
+
+vuint8m2_t 
+test___riscv_vle8_v_u8m2(uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m2(base,31);
+}
+
+vuint8m4_t 
+test___riscv_vle8_v_u8m4(uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m4(base,31);
+}
+
+vuint8m8_t 
+test___riscv_vle8_v_u8m8(uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m8(base,31);
+}
+
+vint16mf4_t
+test___riscv_vle16_v_i16mf4(int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf4(base,31);
+}
+
+vint16mf2_t
+test___riscv_vle16_v_i16mf2(int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf2(base,31);
+}
+
+vint16m1_t
+test___riscv_vle16_v_i16m1(int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m1(base,31);
+}
+
+vint16m2_t
+test___riscv_vle16_v_i16m2(int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m2(base,31);
+}
+
+vint16m4_t
+test___riscv_vle16_v_i16m4(int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m4(base,31);
+}
+
+vint16m8_t
+test___riscv_vle16_v_i16m8(int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m8(base,31);
+}
+
+vuint16mf4_t
+test___riscv_vle16_v_u16mf4(uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf4(base,31);
+}
+
+vuint16mf2_t
+test___riscv_vle16_v_u16mf2(uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf2(base,31);
+}
+
+vuint16m1_t
+test___riscv_vle16_v_u16m1(uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m1(base,31);
+}
+
+vuint16m2_t
+test___riscv_vle16_v_u16m2(uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m2(base,31);
+}
+
+vuint16m4_t
+test___riscv_vle16_v_u16m4(uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m4(base,31);
+}
+
+vuint16m8_t
+test___riscv_vle16_v_u16m8(uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m8(base,31);
+}
+
+vint32mf2_t
+test___riscv_vle32_v_i32mf2(int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32mf2(base,31);
+}
+
+vint32m1_t
+test___riscv_vle32_v_i32m1(int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m1(base,31);
+}
+
+vint32m2_t
+test___riscv_vle32_v_i32m2(int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m2(base,31);
+}
+
+vint32m4_t
+test___riscv_vle32_v_i32m4(int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m4(base,31);
+}
+
+vint32m8_t
+test___riscv_vle32_v_i32m8(int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m8(base,31);
+}
+
+vuint32mf2_t
+test___riscv_vle32_v_u32mf2(uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32mf2(base,31);
+}
+
+vuint32m1_t
+test___riscv_vle32_v_u32m1(uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m1(base,31);
+}
+
+vuint32m2_t
+test___riscv_vle32_v_u32m2(uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m2(base,31);
+}
+
+vuint32m4_t
+test___riscv_vle32_v_u32m4(uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m4(base,31);
+}
+
+vuint32m8_t
+test___riscv_vle32_v_u32m8(uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m8(base,31);
+}
+
+vfloat32mf2_t
+test___riscv_vle32_v_f32mf2(float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32mf2(base,31);
+}
+
+vfloat32m1_t
+test___riscv_vle32_v_f32m1(float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m1(base,31);
+}
+
+vfloat32m2_t
+test___riscv_vle32_v_f32m2(float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m2(base,31);
+}
+
+vfloat32m4_t
+test___riscv_vle32_v_f32m4(float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m4(base,31);
+}
+
+vfloat32m8_t
+test___riscv_vle32_v_f32m8(float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m8(base,31);
+}
+vint64m1_t
+test___riscv_vle64_v_i64m1(int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m1(base,31);
+}
+
+vint64m2_t
+test___riscv_vle64_v_i64m2(int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m2(base,31);
+}
+
+vint64m4_t
+test___riscv_vle64_v_i64m4(int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m4(base,31);
+}
+
+vint64m8_t
+test___riscv_vle64_v_i64m8(int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m8(base,31);
+}
+
+vuint64m1_t
+test___riscv_vle64_v_u64m1(uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m1(base,31);
+}
+
+vuint64m2_t
+test___riscv_vle64_v_u64m2(uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m2(base,31);
+}
+
+vuint64m4_t
+test___riscv_vle64_v_u64m4(uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m4(base,31);
+}
+
+vuint64m8_t
+test___riscv_vle64_v_u64m8(uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m8(base,31);
+}
+
+vfloat64m1_t
+test___riscv_vle64_v_f64m1(double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m1(base,31);
+}
+
+vfloat64m2_t
+test___riscv_vle64_v_f64m2(double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m2(base,31);
+}
+
+vfloat64m4_t
+test___riscv_vle64_v_f64m4(double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m4(base,31);
+}
+
+vfloat64m8_t
+test___riscv_vle64_v_f64m8(double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m8(base,31);
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vle-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vle-3.c
new file mode 100644
index 0000000..ffc9fd5
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vle-3.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t 
+test___riscv_vle8_v_i8mf8(int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf8(base,32);
+}
+
+vint8mf4_t 
+test___riscv_vle8_v_i8mf4(int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf4(base,32);
+}
+
+vint8mf2_t 
+test___riscv_vle8_v_i8mf2(int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf2(base,32);
+}
+
+vint8m1_t 
+test___riscv_vle8_v_i8m1(int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m1(base,32);
+}
+
+vint8m2_t 
+test___riscv_vle8_v_i8m2(int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m2(base,32);
+}
+
+vint8m4_t 
+test___riscv_vle8_v_i8m4(int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m4(base,32);
+}
+
+vint8m8_t 
+test___riscv_vle8_v_i8m8(int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m8(base,32);
+}
+
+vuint8mf8_t 
+test___riscv_vle8_v_u8mf8(uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf8(base,32);
+}
+
+vuint8mf4_t 
+test___riscv_vle8_v_u8mf4(uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf4(base,32);
+}
+
+vuint8mf2_t 
+test___riscv_vle8_v_u8mf2(uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf2(base,32);
+}
+
+vuint8m1_t 
+test___riscv_vle8_v_u8m1(uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m1(base,32);
+}
+
+vuint8m2_t 
+test___riscv_vle8_v_u8m2(uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m2(base,32);
+}
+
+vuint8m4_t 
+test___riscv_vle8_v_u8m4(uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m4(base,32);
+}
+
+vuint8m8_t 
+test___riscv_vle8_v_u8m8(uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m8(base,32);
+}
+
+vint16mf4_t
+test___riscv_vle16_v_i16mf4(int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf4(base,32);
+}
+
+vint16mf2_t
+test___riscv_vle16_v_i16mf2(int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf2(base,32);
+}
+
+vint16m1_t
+test___riscv_vle16_v_i16m1(int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m1(base,32);
+}
+
+vint16m2_t
+test___riscv_vle16_v_i16m2(int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m2(base,32);
+}
+
+vint16m4_t
+test___riscv_vle16_v_i16m4(int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m4(base,32);
+}
+
+vint16m8_t
+test___riscv_vle16_v_i16m8(int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m8(base,32);
+}
+
+vuint16mf4_t
+test___riscv_vle16_v_u16mf4(uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf4(base,32);
+}
+
+vuint16mf2_t
+test___riscv_vle16_v_u16mf2(uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf2(base,32);
+}
+
+vuint16m1_t
+test___riscv_vle16_v_u16m1(uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m1(base,32);
+}
+
+vuint16m2_t
+test___riscv_vle16_v_u16m2(uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m2(base,32);
+}
+
+vuint16m4_t
+test___riscv_vle16_v_u16m4(uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m4(base,32);
+}
+
+vuint16m8_t
+test___riscv_vle16_v_u16m8(uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m8(base,32);
+}
+
+vint32mf2_t
+test___riscv_vle32_v_i32mf2(int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32mf2(base,32);
+}
+
+vint32m1_t
+test___riscv_vle32_v_i32m1(int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m1(base,32);
+}
+
+vint32m2_t
+test___riscv_vle32_v_i32m2(int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m2(base,32);
+}
+
+vint32m4_t
+test___riscv_vle32_v_i32m4(int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m4(base,32);
+}
+
+vint32m8_t
+test___riscv_vle32_v_i32m8(int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m8(base,32);
+}
+
+vuint32mf2_t
+test___riscv_vle32_v_u32mf2(uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32mf2(base,32);
+}
+
+vuint32m1_t
+test___riscv_vle32_v_u32m1(uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m1(base,32);
+}
+
+vuint32m2_t
+test___riscv_vle32_v_u32m2(uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m2(base,32);
+}
+
+vuint32m4_t
+test___riscv_vle32_v_u32m4(uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m4(base,32);
+}
+
+vuint32m8_t
+test___riscv_vle32_v_u32m8(uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m8(base,32);
+}
+
+vfloat32mf2_t
+test___riscv_vle32_v_f32mf2(float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32mf2(base,32);
+}
+
+vfloat32m1_t
+test___riscv_vle32_v_f32m1(float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m1(base,32);
+}
+
+vfloat32m2_t
+test___riscv_vle32_v_f32m2(float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m2(base,32);
+}
+
+vfloat32m4_t
+test___riscv_vle32_v_f32m4(float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m4(base,32);
+}
+
+vfloat32m8_t
+test___riscv_vle32_v_f32m8(float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m8(base,32);
+}
+vint64m1_t
+test___riscv_vle64_v_i64m1(int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m1(base,32);
+}
+
+vint64m2_t
+test___riscv_vle64_v_i64m2(int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m2(base,32);
+}
+
+vint64m4_t
+test___riscv_vle64_v_i64m4(int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m4(base,32);
+}
+
+vint64m8_t
+test___riscv_vle64_v_i64m8(int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m8(base,32);
+}
+
+vuint64m1_t
+test___riscv_vle64_v_u64m1(uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m1(base,32);
+}
+
+vuint64m2_t
+test___riscv_vle64_v_u64m2(uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m2(base,32);
+}
+
+vuint64m4_t
+test___riscv_vle64_v_u64m4(uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m4(base,32);
+}
+
+vuint64m8_t
+test___riscv_vle64_v_u64m8(uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m8(base,32);
+}
+
+vfloat64m1_t
+test___riscv_vle64_v_f64m1(double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m1(base,32);
+}
+
+vfloat64m2_t
+test___riscv_vle64_v_f64m2(double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m2(base,32);
+}
+
+vfloat64m4_t
+test___riscv_vle64_v_f64m4(double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m4(base,32);
+}
+
+vfloat64m8_t
+test___riscv_vle64_v_f64m8(double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m8(base,32);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vle-constraint-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vle-constraint-1.c
index b7cf98b..8d01e20 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/base/vle-constraint-1.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vle-constraint-1.c
@@ -6,7 +6,7 @@
 
 /*
 ** f1:
-**	vsetvli\tzero,4,e32,m1,tu,ma
+**	vsetivli\tzero,4,e32,m1,tu,ma
 **	vle32\.v\tv[0-9]+,0\([a-x0-9]+\)
 **	vle32\.v\tv[0-9]+,0\([a-x0-9]+\)
 **	vse32\.v\tv[0-9]+,0\([a-x0-9]+\)
@@ -23,7 +23,7 @@ void f1 (float * in, float *out)
 ** f2:
 **	vsetvli\t[a-x0-9]+,zero,e8,mf4,ta,ma
 **	vlm.v\tv[0-9]+,0\([a-x0-9]+\)
-**	vsetvli\tzero,4,e32,m1,ta,ma
+**	vsetivli\tzero,4,e32,m1,ta,ma
 **	vle32.v\tv[0-9]+,0\([a-x0-9]+\),v0.t
 **	vse32.v\tv[0-9]+,0\([a-x0-9]+\)
 **	ret
@@ -41,7 +41,7 @@ void f2 (float * in, float *out)
 ** f3:
 **	vsetvli\t[a-x0-9]+,zero,e8,mf4,ta,ma
 **	vlm.v\tv[0-9]+,0\([a-x0-9]+\)
-**	vsetvli\tzero,4,e32,m1,tu,mu
+**	vsetivli\tzero,4,e32,m1,tu,mu
 **	vle32\.v\tv[0-9]+,0\([a-x0-9]+\)
 **	vle32.v\tv[0-9]+,0\([a-x0-9]+\),v0.t
 **	vse32.v\tv[0-9]+,0\([a-x0-9]+\)
@@ -58,7 +58,7 @@ void f3 (float * in, float *out)
 
 /*
 ** f4:
-**	vsetvli\tzero,4,e8,mf8,tu,ma
+**	vsetivli\tzero,4,e8,mf8,tu,ma
 **	vle8\.v\tv[0-9]+,0\([a-x0-9]+\)
 **	vle8\.v\tv[0-9]+,0\([a-x0-9]+\)
 **	vse8\.v\tv[0-9]+,0\([a-x0-9]+\)
@@ -75,7 +75,7 @@ void f4 (int8_t * in, int8_t *out)
 ** f5:
 **	vsetvli\t[a-x0-9]+,zero,e8,mf8,ta,ma
 **	vlm.v\tv[0-9]+,0\([a-x0-9]+\)
-**	vsetvli\tzero,4,e8,mf8,ta,ma
+**	vsetivli\tzero,4,e8,mf8,ta,ma
 **	vle8.v\tv[0-9]+,0\([a-x0-9]+\),v0.t
 **	vse8.v\tv[0-9]+,0\([a-x0-9]+\)
 **	ret
@@ -93,7 +93,7 @@ void f5 (int8_t * in, int8_t *out)
 ** f6:
 **	vsetvli\t[a-x0-9]+,zero,e8,mf8,ta,ma
 **	vlm.v\tv[0-9]+,0\([a-x0-9]+\)
-**	vsetvli\tzero,4,e8,mf8,tu,mu
+**	vsetivli\tzero,4,e8,mf8,tu,mu
 **	vle8\.v\tv[0-9]+,0\([a-x0-9]+\)
 **	vle8.v\tv[0-9]+,0\([a-x0-9]+\),v0.t
 **	vse8.v\tv[0-9]+,0\([a-x0-9]+\)
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vle_m-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vle_m-1.c
new file mode 100644
index 0000000..7944f5e
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vle_m-1.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vle8_v_i8mf8_m(vbool64_t mask,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf8_m(mask,base,vl);
+}
+
+vint8mf4_t
+test___riscv_vle8_v_i8mf4_m(vbool32_t mask,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf4_m(mask,base,vl);
+}
+
+vint8mf2_t
+test___riscv_vle8_v_i8mf2_m(vbool16_t mask,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf2_m(mask,base,vl);
+}
+
+vint8m1_t
+test___riscv_vle8_v_i8m1_m(vbool8_t mask,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m1_m(mask,base,vl);
+}
+
+vint8m2_t
+test___riscv_vle8_v_i8m2_m(vbool4_t mask,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m2_m(mask,base,vl);
+}
+
+vint8m4_t
+test___riscv_vle8_v_i8m4_m(vbool2_t mask,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m4_m(mask,base,vl);
+}
+
+vint8m8_t
+test___riscv_vle8_v_i8m8_m(vbool1_t mask,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m8_m(mask,base,vl);
+}
+
+vuint8mf8_t
+test___riscv_vle8_v_u8mf8_m(vbool64_t mask,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf8_m(mask,base,vl);
+}
+
+vuint8mf4_t
+test___riscv_vle8_v_u8mf4_m(vbool32_t mask,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf4_m(mask,base,vl);
+}
+
+vuint8mf2_t
+test___riscv_vle8_v_u8mf2_m(vbool16_t mask,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf2_m(mask,base,vl);
+}
+
+vuint8m1_t
+test___riscv_vle8_v_u8m1_m(vbool8_t mask,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m1_m(mask,base,vl);
+}
+
+vuint8m2_t
+test___riscv_vle8_v_u8m2_m(vbool4_t mask,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m2_m(mask,base,vl);
+}
+
+vuint8m4_t
+test___riscv_vle8_v_u8m4_m(vbool2_t mask,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m4_m(mask,base,vl);
+}
+
+vuint8m8_t
+test___riscv_vle8_v_u8m8_m(vbool1_t mask,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m8_m(mask,base,vl);
+}
+
+vint16mf4_t
+test___riscv_vle16_v_i16mf4_m(vbool64_t mask,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf4_m(mask,base,vl);
+}
+
+vint16mf2_t
+test___riscv_vle16_v_i16mf2_m(vbool32_t mask,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf2_m(mask,base,vl);
+}
+
+vint16m1_t
+test___riscv_vle16_v_i16m1_m(vbool16_t mask,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m1_m(mask,base,vl);
+}
+
+vint16m2_t
+test___riscv_vle16_v_i16m2_m(vbool8_t mask,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m2_m(mask,base,vl);
+}
+
+vint16m4_t
+test___riscv_vle16_v_i16m4_m(vbool4_t mask,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m4_m(mask,base,vl);
+}
+
+vint16m8_t
+test___riscv_vle16_v_i16m8_m(vbool2_t mask,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m8_m(mask,base,vl);
+}
+
+vuint16mf4_t
+test___riscv_vle16_v_u16mf4_m(vbool64_t mask,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf4_m(mask,base,vl);
+}
+
+vuint16mf2_t
+test___riscv_vle16_v_u16mf2_m(vbool32_t mask,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf2_m(mask,base,vl);
+}
+
+vuint16m1_t
+test___riscv_vle16_v_u16m1_m(vbool16_t mask,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m1_m(mask,base,vl);
+}
+
+vuint16m2_t
+test___riscv_vle16_v_u16m2_m(vbool8_t mask,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m2_m(mask,base,vl);
+}
+
+vuint16m4_t
+test___riscv_vle16_v_u16m4_m(vbool4_t mask,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m4_m(mask,base,vl);
+}
+
+vuint16m8_t
+test___riscv_vle16_v_u16m8_m(vbool2_t mask,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m8_m(mask,base,vl);
+}
+
+vint32mf2_t
+test___riscv_vle32_v_i32mf2_m(vbool64_t mask,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32mf2_m(mask,base,vl);
+}
+
+vint32m1_t
+test___riscv_vle32_v_i32m1_m(vbool32_t mask,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m1_m(mask,base,vl);
+}
+
+vint32m2_t
+test___riscv_vle32_v_i32m2_m(vbool16_t mask,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m2_m(mask,base,vl);
+}
+
+vint32m4_t
+test___riscv_vle32_v_i32m4_m(vbool8_t mask,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m4_m(mask,base,vl);
+}
+
+vint32m8_t
+test___riscv_vle32_v_i32m8_m(vbool4_t mask,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m8_m(mask,base,vl);
+}
+
+vuint32mf2_t
+test___riscv_vle32_v_u32mf2_m(vbool64_t mask,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32mf2_m(mask,base,vl);
+}
+
+vuint32m1_t
+test___riscv_vle32_v_u32m1_m(vbool32_t mask,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m1_m(mask,base,vl);
+}
+
+vuint32m2_t
+test___riscv_vle32_v_u32m2_m(vbool16_t mask,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m2_m(mask,base,vl);
+}
+
+vuint32m4_t
+test___riscv_vle32_v_u32m4_m(vbool8_t mask,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m4_m(mask,base,vl);
+}
+
+vuint32m8_t
+test___riscv_vle32_v_u32m8_m(vbool4_t mask,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m8_m(mask,base,vl);
+}
+
+vfloat32mf2_t
+test___riscv_vle32_v_f32mf2_m(vbool64_t mask,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32mf2_m(mask,base,vl);
+}
+
+vfloat32m1_t
+test___riscv_vle32_v_f32m1_m(vbool32_t mask,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m1_m(mask,base,vl);
+}
+
+vfloat32m2_t
+test___riscv_vle32_v_f32m2_m(vbool16_t mask,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m2_m(mask,base,vl);
+}
+
+vfloat32m4_t
+test___riscv_vle32_v_f32m4_m(vbool8_t mask,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m4_m(mask,base,vl);
+}
+
+vfloat32m8_t
+test___riscv_vle32_v_f32m8_m(vbool4_t mask,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m8_m(mask,base,vl);
+}
+
+vint64m1_t
+test___riscv_vle64_v_i64m1_m(vbool64_t mask,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m1_m(mask,base,vl);
+}
+
+vint64m2_t
+test___riscv_vle64_v_i64m2_m(vbool32_t mask,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m2_m(mask,base,vl);
+}
+
+vint64m4_t
+test___riscv_vle64_v_i64m4_m(vbool16_t mask,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m4_m(mask,base,vl);
+}
+
+vint64m8_t
+test___riscv_vle64_v_i64m8_m(vbool8_t mask,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m8_m(mask,base,vl);
+}
+
+vuint64m1_t
+test___riscv_vle64_v_u64m1_m(vbool64_t mask,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m1_m(mask,base,vl);
+}
+
+vuint64m2_t
+test___riscv_vle64_v_u64m2_m(vbool32_t mask,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m2_m(mask,base,vl);
+}
+
+vuint64m4_t
+test___riscv_vle64_v_u64m4_m(vbool16_t mask,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m4_m(mask,base,vl);
+}
+
+vuint64m8_t
+test___riscv_vle64_v_u64m8_m(vbool8_t mask,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m8_m(mask,base,vl);
+}
+
+vfloat64m1_t
+test___riscv_vle64_v_f64m1_m(vbool64_t mask,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m1_m(mask,base,vl);
+}
+
+vfloat64m2_t
+test___riscv_vle64_v_f64m2_m(vbool32_t mask,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m2_m(mask,base,vl);
+}
+
+vfloat64m4_t
+test___riscv_vle64_v_f64m4_m(vbool16_t mask,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m4_m(mask,base,vl);
+}
+
+vfloat64m8_t
+test___riscv_vle64_v_f64m8_m(vbool8_t mask,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m8_m(mask,base,vl);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vle_m-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vle_m-2.c
new file mode 100644
index 0000000..7d5f601
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vle_m-2.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vle8_v_i8mf8_m(vbool64_t mask,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf8_m(mask,base,31);
+}
+
+vint8mf4_t
+test___riscv_vle8_v_i8mf4_m(vbool32_t mask,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf4_m(mask,base,31);
+}
+
+vint8mf2_t
+test___riscv_vle8_v_i8mf2_m(vbool16_t mask,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf2_m(mask,base,31);
+}
+
+vint8m1_t
+test___riscv_vle8_v_i8m1_m(vbool8_t mask,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m1_m(mask,base,31);
+}
+
+vint8m2_t
+test___riscv_vle8_v_i8m2_m(vbool4_t mask,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m2_m(mask,base,31);
+}
+
+vint8m4_t
+test___riscv_vle8_v_i8m4_m(vbool2_t mask,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m4_m(mask,base,31);
+}
+
+vint8m8_t
+test___riscv_vle8_v_i8m8_m(vbool1_t mask,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m8_m(mask,base,31);
+}
+
+vuint8mf8_t
+test___riscv_vle8_v_u8mf8_m(vbool64_t mask,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf8_m(mask,base,31);
+}
+
+vuint8mf4_t
+test___riscv_vle8_v_u8mf4_m(vbool32_t mask,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf4_m(mask,base,31);
+}
+
+vuint8mf2_t
+test___riscv_vle8_v_u8mf2_m(vbool16_t mask,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf2_m(mask,base,31);
+}
+
+vuint8m1_t
+test___riscv_vle8_v_u8m1_m(vbool8_t mask,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m1_m(mask,base,31);
+}
+
+vuint8m2_t
+test___riscv_vle8_v_u8m2_m(vbool4_t mask,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m2_m(mask,base,31);
+}
+
+vuint8m4_t
+test___riscv_vle8_v_u8m4_m(vbool2_t mask,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m4_m(mask,base,31);
+}
+
+vuint8m8_t
+test___riscv_vle8_v_u8m8_m(vbool1_t mask,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m8_m(mask,base,31);
+}
+
+vint16mf4_t
+test___riscv_vle16_v_i16mf4_m(vbool64_t mask,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf4_m(mask,base,31);
+}
+
+vint16mf2_t
+test___riscv_vle16_v_i16mf2_m(vbool32_t mask,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf2_m(mask,base,31);
+}
+
+vint16m1_t
+test___riscv_vle16_v_i16m1_m(vbool16_t mask,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m1_m(mask,base,31);
+}
+
+vint16m2_t
+test___riscv_vle16_v_i16m2_m(vbool8_t mask,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m2_m(mask,base,31);
+}
+
+vint16m4_t
+test___riscv_vle16_v_i16m4_m(vbool4_t mask,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m4_m(mask,base,31);
+}
+
+vint16m8_t
+test___riscv_vle16_v_i16m8_m(vbool2_t mask,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m8_m(mask,base,31);
+}
+
+vuint16mf4_t
+test___riscv_vle16_v_u16mf4_m(vbool64_t mask,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf4_m(mask,base,31);
+}
+
+vuint16mf2_t
+test___riscv_vle16_v_u16mf2_m(vbool32_t mask,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf2_m(mask,base,31);
+}
+
+vuint16m1_t
+test___riscv_vle16_v_u16m1_m(vbool16_t mask,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m1_m(mask,base,31);
+}
+
+vuint16m2_t
+test___riscv_vle16_v_u16m2_m(vbool8_t mask,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m2_m(mask,base,31);
+}
+
+vuint16m4_t
+test___riscv_vle16_v_u16m4_m(vbool4_t mask,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m4_m(mask,base,31);
+}
+
+vuint16m8_t
+test___riscv_vle16_v_u16m8_m(vbool2_t mask,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m8_m(mask,base,31);
+}
+
+vint32mf2_t
+test___riscv_vle32_v_i32mf2_m(vbool64_t mask,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32mf2_m(mask,base,31);
+}
+
+vint32m1_t
+test___riscv_vle32_v_i32m1_m(vbool32_t mask,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m1_m(mask,base,31);
+}
+
+vint32m2_t
+test___riscv_vle32_v_i32m2_m(vbool16_t mask,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m2_m(mask,base,31);
+}
+
+vint32m4_t
+test___riscv_vle32_v_i32m4_m(vbool8_t mask,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m4_m(mask,base,31);
+}
+
+vint32m8_t
+test___riscv_vle32_v_i32m8_m(vbool4_t mask,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m8_m(mask,base,31);
+}
+
+vuint32mf2_t
+test___riscv_vle32_v_u32mf2_m(vbool64_t mask,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32mf2_m(mask,base,31);
+}
+
+vuint32m1_t
+test___riscv_vle32_v_u32m1_m(vbool32_t mask,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m1_m(mask,base,31);
+}
+
+vuint32m2_t
+test___riscv_vle32_v_u32m2_m(vbool16_t mask,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m2_m(mask,base,31);
+}
+
+vuint32m4_t
+test___riscv_vle32_v_u32m4_m(vbool8_t mask,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m4_m(mask,base,31);
+}
+
+vuint32m8_t
+test___riscv_vle32_v_u32m8_m(vbool4_t mask,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m8_m(mask,base,31);
+}
+
+vfloat32mf2_t
+test___riscv_vle32_v_f32mf2_m(vbool64_t mask,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32mf2_m(mask,base,31);
+}
+
+vfloat32m1_t
+test___riscv_vle32_v_f32m1_m(vbool32_t mask,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m1_m(mask,base,31);
+}
+
+vfloat32m2_t
+test___riscv_vle32_v_f32m2_m(vbool16_t mask,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m2_m(mask,base,31);
+}
+
+vfloat32m4_t
+test___riscv_vle32_v_f32m4_m(vbool8_t mask,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m4_m(mask,base,31);
+}
+
+vfloat32m8_t
+test___riscv_vle32_v_f32m8_m(vbool4_t mask,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m8_m(mask,base,31);
+}
+
+vint64m1_t
+test___riscv_vle64_v_i64m1_m(vbool64_t mask,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m1_m(mask,base,31);
+}
+
+vint64m2_t
+test___riscv_vle64_v_i64m2_m(vbool32_t mask,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m2_m(mask,base,31);
+}
+
+vint64m4_t
+test___riscv_vle64_v_i64m4_m(vbool16_t mask,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m4_m(mask,base,31);
+}
+
+vint64m8_t
+test___riscv_vle64_v_i64m8_m(vbool8_t mask,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m8_m(mask,base,31);
+}
+
+vuint64m1_t
+test___riscv_vle64_v_u64m1_m(vbool64_t mask,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m1_m(mask,base,31);
+}
+
+vuint64m2_t
+test___riscv_vle64_v_u64m2_m(vbool32_t mask,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m2_m(mask,base,31);
+}
+
+vuint64m4_t
+test___riscv_vle64_v_u64m4_m(vbool16_t mask,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m4_m(mask,base,31);
+}
+
+vuint64m8_t
+test___riscv_vle64_v_u64m8_m(vbool8_t mask,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m8_m(mask,base,31);
+}
+
+vfloat64m1_t
+test___riscv_vle64_v_f64m1_m(vbool64_t mask,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m1_m(mask,base,31);
+}
+
+vfloat64m2_t
+test___riscv_vle64_v_f64m2_m(vbool32_t mask,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m2_m(mask,base,31);
+}
+
+vfloat64m4_t
+test___riscv_vle64_v_f64m4_m(vbool16_t mask,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m4_m(mask,base,31);
+}
+
+vfloat64m8_t
+test___riscv_vle64_v_f64m8_m(vbool8_t mask,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m8_m(mask,base,31);
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vle_m-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vle_m-3.c
new file mode 100644
index 0000000..a3aca9f
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vle_m-3.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vle8_v_i8mf8_m(vbool64_t mask,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf8_m(mask,base,32);
+}
+
+vint8mf4_t
+test___riscv_vle8_v_i8mf4_m(vbool32_t mask,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf4_m(mask,base,32);
+}
+
+vint8mf2_t
+test___riscv_vle8_v_i8mf2_m(vbool16_t mask,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf2_m(mask,base,32);
+}
+
+vint8m1_t
+test___riscv_vle8_v_i8m1_m(vbool8_t mask,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m1_m(mask,base,32);
+}
+
+vint8m2_t
+test___riscv_vle8_v_i8m2_m(vbool4_t mask,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m2_m(mask,base,32);
+}
+
+vint8m4_t
+test___riscv_vle8_v_i8m4_m(vbool2_t mask,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m4_m(mask,base,32);
+}
+
+vint8m8_t
+test___riscv_vle8_v_i8m8_m(vbool1_t mask,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m8_m(mask,base,32);
+}
+
+vuint8mf8_t
+test___riscv_vle8_v_u8mf8_m(vbool64_t mask,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf8_m(mask,base,32);
+}
+
+vuint8mf4_t
+test___riscv_vle8_v_u8mf4_m(vbool32_t mask,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf4_m(mask,base,32);
+}
+
+vuint8mf2_t
+test___riscv_vle8_v_u8mf2_m(vbool16_t mask,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf2_m(mask,base,32);
+}
+
+vuint8m1_t
+test___riscv_vle8_v_u8m1_m(vbool8_t mask,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m1_m(mask,base,32);
+}
+
+vuint8m2_t
+test___riscv_vle8_v_u8m2_m(vbool4_t mask,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m2_m(mask,base,32);
+}
+
+vuint8m4_t
+test___riscv_vle8_v_u8m4_m(vbool2_t mask,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m4_m(mask,base,32);
+}
+
+vuint8m8_t
+test___riscv_vle8_v_u8m8_m(vbool1_t mask,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m8_m(mask,base,32);
+}
+
+vint16mf4_t
+test___riscv_vle16_v_i16mf4_m(vbool64_t mask,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf4_m(mask,base,32);
+}
+
+vint16mf2_t
+test___riscv_vle16_v_i16mf2_m(vbool32_t mask,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf2_m(mask,base,32);
+}
+
+vint16m1_t
+test___riscv_vle16_v_i16m1_m(vbool16_t mask,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m1_m(mask,base,32);
+}
+
+vint16m2_t
+test___riscv_vle16_v_i16m2_m(vbool8_t mask,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m2_m(mask,base,32);
+}
+
+vint16m4_t
+test___riscv_vle16_v_i16m4_m(vbool4_t mask,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m4_m(mask,base,32);
+}
+
+vint16m8_t
+test___riscv_vle16_v_i16m8_m(vbool2_t mask,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m8_m(mask,base,32);
+}
+
+vuint16mf4_t
+test___riscv_vle16_v_u16mf4_m(vbool64_t mask,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf4_m(mask,base,32);
+}
+
+vuint16mf2_t
+test___riscv_vle16_v_u16mf2_m(vbool32_t mask,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf2_m(mask,base,32);
+}
+
+vuint16m1_t
+test___riscv_vle16_v_u16m1_m(vbool16_t mask,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m1_m(mask,base,32);
+}
+
+vuint16m2_t
+test___riscv_vle16_v_u16m2_m(vbool8_t mask,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m2_m(mask,base,32);
+}
+
+vuint16m4_t
+test___riscv_vle16_v_u16m4_m(vbool4_t mask,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m4_m(mask,base,32);
+}
+
+vuint16m8_t
+test___riscv_vle16_v_u16m8_m(vbool2_t mask,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m8_m(mask,base,32);
+}
+
+vint32mf2_t
+test___riscv_vle32_v_i32mf2_m(vbool64_t mask,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32mf2_m(mask,base,32);
+}
+
+vint32m1_t
+test___riscv_vle32_v_i32m1_m(vbool32_t mask,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m1_m(mask,base,32);
+}
+
+vint32m2_t
+test___riscv_vle32_v_i32m2_m(vbool16_t mask,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m2_m(mask,base,32);
+}
+
+vint32m4_t
+test___riscv_vle32_v_i32m4_m(vbool8_t mask,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m4_m(mask,base,32);
+}
+
+vint32m8_t
+test___riscv_vle32_v_i32m8_m(vbool4_t mask,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m8_m(mask,base,32);
+}
+
+vuint32mf2_t
+test___riscv_vle32_v_u32mf2_m(vbool64_t mask,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32mf2_m(mask,base,32);
+}
+
+vuint32m1_t
+test___riscv_vle32_v_u32m1_m(vbool32_t mask,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m1_m(mask,base,32);
+}
+
+vuint32m2_t
+test___riscv_vle32_v_u32m2_m(vbool16_t mask,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m2_m(mask,base,32);
+}
+
+vuint32m4_t
+test___riscv_vle32_v_u32m4_m(vbool8_t mask,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m4_m(mask,base,32);
+}
+
+vuint32m8_t
+test___riscv_vle32_v_u32m8_m(vbool4_t mask,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m8_m(mask,base,32);
+}
+
+vfloat32mf2_t
+test___riscv_vle32_v_f32mf2_m(vbool64_t mask,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32mf2_m(mask,base,32);
+}
+
+vfloat32m1_t
+test___riscv_vle32_v_f32m1_m(vbool32_t mask,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m1_m(mask,base,32);
+}
+
+vfloat32m2_t
+test___riscv_vle32_v_f32m2_m(vbool16_t mask,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m2_m(mask,base,32);
+}
+
+vfloat32m4_t
+test___riscv_vle32_v_f32m4_m(vbool8_t mask,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m4_m(mask,base,32);
+}
+
+vfloat32m8_t
+test___riscv_vle32_v_f32m8_m(vbool4_t mask,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m8_m(mask,base,32);
+}
+
+vint64m1_t
+test___riscv_vle64_v_i64m1_m(vbool64_t mask,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m1_m(mask,base,32);
+}
+
+vint64m2_t
+test___riscv_vle64_v_i64m2_m(vbool32_t mask,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m2_m(mask,base,32);
+}
+
+vint64m4_t
+test___riscv_vle64_v_i64m4_m(vbool16_t mask,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m4_m(mask,base,32);
+}
+
+vint64m8_t
+test___riscv_vle64_v_i64m8_m(vbool8_t mask,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m8_m(mask,base,32);
+}
+
+vuint64m1_t
+test___riscv_vle64_v_u64m1_m(vbool64_t mask,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m1_m(mask,base,32);
+}
+
+vuint64m2_t
+test___riscv_vle64_v_u64m2_m(vbool32_t mask,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m2_m(mask,base,32);
+}
+
+vuint64m4_t
+test___riscv_vle64_v_u64m4_m(vbool16_t mask,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m4_m(mask,base,32);
+}
+
+vuint64m8_t
+test___riscv_vle64_v_u64m8_m(vbool8_t mask,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m8_m(mask,base,32);
+}
+
+vfloat64m1_t
+test___riscv_vle64_v_f64m1_m(vbool64_t mask,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m1_m(mask,base,32);
+}
+
+vfloat64m2_t
+test___riscv_vle64_v_f64m2_m(vbool32_t mask,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m2_m(mask,base,32);
+}
+
+vfloat64m4_t
+test___riscv_vle64_v_f64m4_m(vbool16_t mask,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m4_m(mask,base,32);
+}
+
+vfloat64m8_t
+test___riscv_vle64_v_f64m8_m(vbool8_t mask,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m8_m(mask,base,32);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vle_mu-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vle_mu-1.c
new file mode 100644
index 0000000..2544991
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vle_mu-1.c
@@ -0,0 +1,344 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vle8_v_i8mf8_mu(vbool64_t mask,vint8mf8_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf8_mu(mask,merge,base,vl);
+}
+
+vint8mf4_t
+test___riscv_vle8_v_i8mf4_mu(vbool32_t mask,vint8mf4_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf4_mu(mask,merge,base,vl);
+}
+
+vint8mf2_t
+test___riscv_vle8_v_i8mf2_mu(vbool16_t mask,vint8mf2_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf2_mu(mask,merge,base,vl);
+}
+
+vint8m1_t
+test___riscv_vle8_v_i8m1_mu(vbool8_t mask,vint8m1_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m1_mu(mask,merge,base,vl);
+}
+
+vint8m2_t
+test___riscv_vle8_v_i8m2_mu(vbool4_t mask,vint8m2_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m2_mu(mask,merge,base,vl);
+}
+
+vint8m4_t
+test___riscv_vle8_v_i8m4_mu(vbool2_t mask,vint8m4_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m4_mu(mask,merge,base,vl);
+}
+
+vint8m8_t
+test___riscv_vle8_v_i8m8_mu(vbool1_t mask,vint8m8_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m8_mu(mask,merge,base,vl);
+}
+
+vuint8mf8_t
+test___riscv_vle8_v_u8mf8_mu(vbool64_t mask,vuint8mf8_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf8_mu(mask,merge,base,vl);
+}
+
+vuint8mf4_t
+test___riscv_vle8_v_u8mf4_mu(vbool32_t mask,vuint8mf4_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf4_mu(mask,merge,base,vl);
+}
+
+vuint8mf2_t
+test___riscv_vle8_v_u8mf2_mu(vbool16_t mask,vuint8mf2_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf2_mu(mask,merge,base,vl);
+}
+
+vuint8m1_t
+test___riscv_vle8_v_u8m1_mu(vbool8_t mask,vuint8m1_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m1_mu(mask,merge,base,vl);
+}
+
+vuint8m2_t
+test___riscv_vle8_v_u8m2_mu(vbool4_t mask,vuint8m2_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m2_mu(mask,merge,base,vl);
+}
+
+vuint8m4_t
+test___riscv_vle8_v_u8m4_mu(vbool2_t mask,vuint8m4_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m4_mu(mask,merge,base,vl);
+}
+
+vuint8m8_t
+test___riscv_vle8_v_u8m8_mu(vbool1_t mask,vuint8m8_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m8_mu(mask,merge,base,vl);
+}
+
+vint16mf4_t
+test___riscv_vle16_v_i16mf4_mu(vbool64_t mask,vint16mf4_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf4_mu(mask,merge,base,vl);
+}
+
+vint16mf2_t
+test___riscv_vle16_v_i16mf2_mu(vbool32_t mask,vint16mf2_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf2_mu(mask,merge,base,vl);
+}
+
+vint16m1_t
+test___riscv_vle16_v_i16m1_mu(vbool16_t mask,vint16m1_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m1_mu(mask,merge,base,vl);
+}
+
+vint16m2_t
+test___riscv_vle16_v_i16m2_mu(vbool8_t mask,vint16m2_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m2_mu(mask,merge,base,vl);
+}
+
+vint16m4_t
+test___riscv_vle16_v_i16m4_mu(vbool4_t mask,vint16m4_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m4_mu(mask,merge,base,vl);
+}
+
+vint16m8_t
+test___riscv_vle16_v_i16m8_mu(vbool2_t mask,vint16m8_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m8_mu(mask,merge,base,vl);
+}
+
+vuint16mf4_t
+test___riscv_vle16_v_u16mf4_mu(vbool64_t mask,vuint16mf4_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf4_mu(mask,merge,base,vl);
+}
+
+vuint16mf2_t
+test___riscv_vle16_v_u16mf2_mu(vbool32_t mask,vuint16mf2_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf2_mu(mask,merge,base,vl);
+}
+
+vuint16m1_t
+test___riscv_vle16_v_u16m1_mu(vbool16_t mask,vuint16m1_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m1_mu(mask,merge,base,vl);
+}
+
+vuint16m2_t
+test___riscv_vle16_v_u16m2_mu(vbool8_t mask,vuint16m2_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m2_mu(mask,merge,base,vl);
+}
+
+vuint16m4_t
+test___riscv_vle16_v_u16m4_mu(vbool4_t mask,vuint16m4_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m4_mu(mask,merge,base,vl);
+}
+
+vuint16m8_t
+test___riscv_vle16_v_u16m8_mu(vbool2_t mask,vuint16m8_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m8_mu(mask,merge,base,vl);
+}
+
+vint32mf2_t
+test___riscv_vle32_v_i32mf2_mu(vbool64_t mask,vint32mf2_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32mf2_mu(mask,merge,base,vl);
+}
+
+vint32m1_t
+test___riscv_vle32_v_i32m1_mu(vbool32_t mask,vint32m1_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m1_mu(mask,merge,base,vl);
+}
+
+vint32m2_t
+test___riscv_vle32_v_i32m2_mu(vbool16_t mask,vint32m2_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m2_mu(mask,merge,base,vl);
+}
+
+vint32m4_t
+test___riscv_vle32_v_i32m4_mu(vbool8_t mask,vint32m4_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m4_mu(mask,merge,base,vl);
+}
+
+vint32m8_t
+test___riscv_vle32_v_i32m8_mu(vbool4_t mask,vint32m8_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m8_mu(mask,merge,base,vl);
+}
+
+vuint32mf2_t
+test___riscv_vle32_v_u32mf2_mu(vbool64_t mask,vuint32mf2_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32mf2_mu(mask,merge,base,vl);
+}
+
+vuint32m1_t
+test___riscv_vle32_v_u32m1_mu(vbool32_t mask,vuint32m1_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m1_mu(mask,merge,base,vl);
+}
+
+vuint32m2_t
+test___riscv_vle32_v_u32m2_mu(vbool16_t mask,vuint32m2_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m2_mu(mask,merge,base,vl);
+}
+
+vuint32m4_t
+test___riscv_vle32_v_u32m4_mu(vbool8_t mask,vuint32m4_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m4_mu(mask,merge,base,vl);
+}
+
+vuint32m8_t
+test___riscv_vle32_v_u32m8_mu(vbool4_t mask,vuint32m8_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m8_mu(mask,merge,base,vl);
+}
+
+vfloat32mf2_t
+test___riscv_vle32_v_f32mf2_mu(vbool64_t mask,vfloat32mf2_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32mf2_mu(mask,merge,base,vl);
+}
+
+vfloat32m1_t
+test___riscv_vle32_v_f32m1_mu(vbool32_t mask,vfloat32m1_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m1_mu(mask,merge,base,vl);
+}
+
+vfloat32m2_t
+test___riscv_vle32_v_f32m2_mu(vbool16_t mask,vfloat32m2_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m2_mu(mask,merge,base,vl);
+}
+
+vfloat32m4_t
+test___riscv_vle32_v_f32m4_mu(vbool8_t mask,vfloat32m4_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m4_mu(mask,merge,base,vl);
+}
+
+vfloat32m8_t
+test___riscv_vle32_v_f32m8_mu(vbool4_t mask,vfloat32m8_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m8_mu(mask,merge,base,vl);
+}
+vint64m1_t
+test___riscv_vle64_v_i64m1_mu(vbool64_t mask,vint64m1_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m1_mu(mask,merge,base,vl);
+}
+
+vint64m2_t
+test___riscv_vle64_v_i64m2_mu(vbool32_t mask,vint64m2_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m2_mu(mask,merge,base,vl);
+}
+
+vint64m4_t
+test___riscv_vle64_v_i64m4_mu(vbool16_t mask,vint64m4_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m4_mu(mask,merge,base,vl);
+}
+
+vint64m8_t
+test___riscv_vle64_v_i64m8_mu(vbool8_t mask,vint64m8_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m8_mu(mask,merge,base,vl);
+}
+
+vuint64m1_t
+test___riscv_vle64_v_u64m1_mu(vbool64_t mask,vuint64m1_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m1_mu(mask,merge,base,vl);
+}
+
+vuint64m2_t
+test___riscv_vle64_v_u64m2_mu(vbool32_t mask,vuint64m2_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m2_mu(mask,merge,base,vl);
+}
+
+vuint64m4_t
+test___riscv_vle64_v_u64m4_mu(vbool16_t mask,vuint64m4_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m4_mu(mask,merge,base,vl);
+}
+
+vuint64m8_t
+test___riscv_vle64_v_u64m8_mu(vbool8_t mask,vuint64m8_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m8_mu(mask,merge,base,vl);
+}
+
+vfloat64m1_t
+test___riscv_vle64_v_f64m1_mu(vbool64_t mask,vfloat64m1_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m1_mu(mask,merge,base,vl);
+}
+
+vfloat64m2_t
+test___riscv_vle64_v_f64m2_mu(vbool32_t mask,vfloat64m2_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m2_mu(mask,merge,base,vl);
+}
+
+vfloat64m4_t
+test___riscv_vle64_v_f64m4_mu(vbool16_t mask,vfloat64m4_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m4_mu(mask,merge,base,vl);
+}
+
+vfloat64m8_t
+test___riscv_vle64_v_f64m8_mu(vbool8_t mask,vfloat64m8_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m8_mu(mask,merge,base,vl);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*mu\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vle_mu-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vle_mu-2.c
new file mode 100644
index 0000000..9440cb1
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vle_mu-2.c
@@ -0,0 +1,344 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vle8_v_i8mf8_mu(vbool64_t mask,vint8mf8_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf8_mu(mask,merge,base,31);
+}
+
+vint8mf4_t
+test___riscv_vle8_v_i8mf4_mu(vbool32_t mask,vint8mf4_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf4_mu(mask,merge,base,31);
+}
+
+vint8mf2_t
+test___riscv_vle8_v_i8mf2_mu(vbool16_t mask,vint8mf2_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf2_mu(mask,merge,base,31);
+}
+
+vint8m1_t
+test___riscv_vle8_v_i8m1_mu(vbool8_t mask,vint8m1_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m1_mu(mask,merge,base,31);
+}
+
+vint8m2_t
+test___riscv_vle8_v_i8m2_mu(vbool4_t mask,vint8m2_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m2_mu(mask,merge,base,31);
+}
+
+vint8m4_t
+test___riscv_vle8_v_i8m4_mu(vbool2_t mask,vint8m4_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m4_mu(mask,merge,base,31);
+}
+
+vint8m8_t
+test___riscv_vle8_v_i8m8_mu(vbool1_t mask,vint8m8_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m8_mu(mask,merge,base,31);
+}
+
+vuint8mf8_t
+test___riscv_vle8_v_u8mf8_mu(vbool64_t mask,vuint8mf8_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf8_mu(mask,merge,base,31);
+}
+
+vuint8mf4_t
+test___riscv_vle8_v_u8mf4_mu(vbool32_t mask,vuint8mf4_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf4_mu(mask,merge,base,31);
+}
+
+vuint8mf2_t
+test___riscv_vle8_v_u8mf2_mu(vbool16_t mask,vuint8mf2_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf2_mu(mask,merge,base,31);
+}
+
+vuint8m1_t
+test___riscv_vle8_v_u8m1_mu(vbool8_t mask,vuint8m1_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m1_mu(mask,merge,base,31);
+}
+
+vuint8m2_t
+test___riscv_vle8_v_u8m2_mu(vbool4_t mask,vuint8m2_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m2_mu(mask,merge,base,31);
+}
+
+vuint8m4_t
+test___riscv_vle8_v_u8m4_mu(vbool2_t mask,vuint8m4_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m4_mu(mask,merge,base,31);
+}
+
+vuint8m8_t
+test___riscv_vle8_v_u8m8_mu(vbool1_t mask,vuint8m8_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m8_mu(mask,merge,base,31);
+}
+
+vint16mf4_t
+test___riscv_vle16_v_i16mf4_mu(vbool64_t mask,vint16mf4_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf4_mu(mask,merge,base,31);
+}
+
+vint16mf2_t
+test___riscv_vle16_v_i16mf2_mu(vbool32_t mask,vint16mf2_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf2_mu(mask,merge,base,31);
+}
+
+vint16m1_t
+test___riscv_vle16_v_i16m1_mu(vbool16_t mask,vint16m1_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m1_mu(mask,merge,base,31);
+}
+
+vint16m2_t
+test___riscv_vle16_v_i16m2_mu(vbool8_t mask,vint16m2_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m2_mu(mask,merge,base,31);
+}
+
+vint16m4_t
+test___riscv_vle16_v_i16m4_mu(vbool4_t mask,vint16m4_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m4_mu(mask,merge,base,31);
+}
+
+vint16m8_t
+test___riscv_vle16_v_i16m8_mu(vbool2_t mask,vint16m8_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m8_mu(mask,merge,base,31);
+}
+
+vuint16mf4_t
+test___riscv_vle16_v_u16mf4_mu(vbool64_t mask,vuint16mf4_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf4_mu(mask,merge,base,31);
+}
+
+vuint16mf2_t
+test___riscv_vle16_v_u16mf2_mu(vbool32_t mask,vuint16mf2_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf2_mu(mask,merge,base,31);
+}
+
+vuint16m1_t
+test___riscv_vle16_v_u16m1_mu(vbool16_t mask,vuint16m1_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m1_mu(mask,merge,base,31);
+}
+
+vuint16m2_t
+test___riscv_vle16_v_u16m2_mu(vbool8_t mask,vuint16m2_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m2_mu(mask,merge,base,31);
+}
+
+vuint16m4_t
+test___riscv_vle16_v_u16m4_mu(vbool4_t mask,vuint16m4_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m4_mu(mask,merge,base,31);
+}
+
+vuint16m8_t
+test___riscv_vle16_v_u16m8_mu(vbool2_t mask,vuint16m8_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m8_mu(mask,merge,base,31);
+}
+
+vint32mf2_t
+test___riscv_vle32_v_i32mf2_mu(vbool64_t mask,vint32mf2_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32mf2_mu(mask,merge,base,31);
+}
+
+vint32m1_t
+test___riscv_vle32_v_i32m1_mu(vbool32_t mask,vint32m1_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m1_mu(mask,merge,base,31);
+}
+
+vint32m2_t
+test___riscv_vle32_v_i32m2_mu(vbool16_t mask,vint32m2_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m2_mu(mask,merge,base,31);
+}
+
+vint32m4_t
+test___riscv_vle32_v_i32m4_mu(vbool8_t mask,vint32m4_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m4_mu(mask,merge,base,31);
+}
+
+vint32m8_t
+test___riscv_vle32_v_i32m8_mu(vbool4_t mask,vint32m8_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m8_mu(mask,merge,base,31);
+}
+
+vuint32mf2_t
+test___riscv_vle32_v_u32mf2_mu(vbool64_t mask,vuint32mf2_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32mf2_mu(mask,merge,base,31);
+}
+
+vuint32m1_t
+test___riscv_vle32_v_u32m1_mu(vbool32_t mask,vuint32m1_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m1_mu(mask,merge,base,31);
+}
+
+vuint32m2_t
+test___riscv_vle32_v_u32m2_mu(vbool16_t mask,vuint32m2_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m2_mu(mask,merge,base,31);
+}
+
+vuint32m4_t
+test___riscv_vle32_v_u32m4_mu(vbool8_t mask,vuint32m4_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m4_mu(mask,merge,base,31);
+}
+
+vuint32m8_t
+test___riscv_vle32_v_u32m8_mu(vbool4_t mask,vuint32m8_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m8_mu(mask,merge,base,31);
+}
+
+vfloat32mf2_t
+test___riscv_vle32_v_f32mf2_mu(vbool64_t mask,vfloat32mf2_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32mf2_mu(mask,merge,base,31);
+}
+
+vfloat32m1_t
+test___riscv_vle32_v_f32m1_mu(vbool32_t mask,vfloat32m1_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m1_mu(mask,merge,base,31);
+}
+
+vfloat32m2_t
+test___riscv_vle32_v_f32m2_mu(vbool16_t mask,vfloat32m2_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m2_mu(mask,merge,base,31);
+}
+
+vfloat32m4_t
+test___riscv_vle32_v_f32m4_mu(vbool8_t mask,vfloat32m4_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m4_mu(mask,merge,base,31);
+}
+
+vfloat32m8_t
+test___riscv_vle32_v_f32m8_mu(vbool4_t mask,vfloat32m8_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m8_mu(mask,merge,base,31);
+}
+vint64m1_t
+test___riscv_vle64_v_i64m1_mu(vbool64_t mask,vint64m1_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m1_mu(mask,merge,base,31);
+}
+
+vint64m2_t
+test___riscv_vle64_v_i64m2_mu(vbool32_t mask,vint64m2_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m2_mu(mask,merge,base,31);
+}
+
+vint64m4_t
+test___riscv_vle64_v_i64m4_mu(vbool16_t mask,vint64m4_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m4_mu(mask,merge,base,31);
+}
+
+vint64m8_t
+test___riscv_vle64_v_i64m8_mu(vbool8_t mask,vint64m8_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m8_mu(mask,merge,base,31);
+}
+
+vuint64m1_t
+test___riscv_vle64_v_u64m1_mu(vbool64_t mask,vuint64m1_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m1_mu(mask,merge,base,31);
+}
+
+vuint64m2_t
+test___riscv_vle64_v_u64m2_mu(vbool32_t mask,vuint64m2_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m2_mu(mask,merge,base,31);
+}
+
+vuint64m4_t
+test___riscv_vle64_v_u64m4_mu(vbool16_t mask,vuint64m4_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m4_mu(mask,merge,base,31);
+}
+
+vuint64m8_t
+test___riscv_vle64_v_u64m8_mu(vbool8_t mask,vuint64m8_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m8_mu(mask,merge,base,31);
+}
+
+vfloat64m1_t
+test___riscv_vle64_v_f64m1_mu(vbool64_t mask,vfloat64m1_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m1_mu(mask,merge,base,31);
+}
+
+vfloat64m2_t
+test___riscv_vle64_v_f64m2_mu(vbool32_t mask,vfloat64m2_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m2_mu(mask,merge,base,31);
+}
+
+vfloat64m4_t
+test___riscv_vle64_v_f64m4_mu(vbool16_t mask,vfloat64m4_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m4_mu(mask,merge,base,31);
+}
+
+vfloat64m8_t
+test___riscv_vle64_v_f64m8_mu(vbool8_t mask,vfloat64m8_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m8_mu(mask,merge,base,31);
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*t[au],\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*mu\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*mu\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*mu\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*mu\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*mu\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*mu\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*mu\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*mu\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vle_mu-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vle_mu-3.c
new file mode 100644
index 0000000..f1eea5f
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vle_mu-3.c
@@ -0,0 +1,344 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vle8_v_i8mf8_mu(vbool64_t mask,vint8mf8_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf8_mu(mask,merge,base,32);
+}
+
+vint8mf4_t
+test___riscv_vle8_v_i8mf4_mu(vbool32_t mask,vint8mf4_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf4_mu(mask,merge,base,32);
+}
+
+vint8mf2_t
+test___riscv_vle8_v_i8mf2_mu(vbool16_t mask,vint8mf2_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf2_mu(mask,merge,base,32);
+}
+
+vint8m1_t
+test___riscv_vle8_v_i8m1_mu(vbool8_t mask,vint8m1_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m1_mu(mask,merge,base,32);
+}
+
+vint8m2_t
+test___riscv_vle8_v_i8m2_mu(vbool4_t mask,vint8m2_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m2_mu(mask,merge,base,32);
+}
+
+vint8m4_t
+test___riscv_vle8_v_i8m4_mu(vbool2_t mask,vint8m4_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m4_mu(mask,merge,base,32);
+}
+
+vint8m8_t
+test___riscv_vle8_v_i8m8_mu(vbool1_t mask,vint8m8_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m8_mu(mask,merge,base,32);
+}
+
+vuint8mf8_t
+test___riscv_vle8_v_u8mf8_mu(vbool64_t mask,vuint8mf8_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf8_mu(mask,merge,base,32);
+}
+
+vuint8mf4_t
+test___riscv_vle8_v_u8mf4_mu(vbool32_t mask,vuint8mf4_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf4_mu(mask,merge,base,32);
+}
+
+vuint8mf2_t
+test___riscv_vle8_v_u8mf2_mu(vbool16_t mask,vuint8mf2_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf2_mu(mask,merge,base,32);
+}
+
+vuint8m1_t
+test___riscv_vle8_v_u8m1_mu(vbool8_t mask,vuint8m1_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m1_mu(mask,merge,base,32);
+}
+
+vuint8m2_t
+test___riscv_vle8_v_u8m2_mu(vbool4_t mask,vuint8m2_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m2_mu(mask,merge,base,32);
+}
+
+vuint8m4_t
+test___riscv_vle8_v_u8m4_mu(vbool2_t mask,vuint8m4_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m4_mu(mask,merge,base,32);
+}
+
+vuint8m8_t
+test___riscv_vle8_v_u8m8_mu(vbool1_t mask,vuint8m8_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m8_mu(mask,merge,base,32);
+}
+
+vint16mf4_t
+test___riscv_vle16_v_i16mf4_mu(vbool64_t mask,vint16mf4_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf4_mu(mask,merge,base,32);
+}
+
+vint16mf2_t
+test___riscv_vle16_v_i16mf2_mu(vbool32_t mask,vint16mf2_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf2_mu(mask,merge,base,32);
+}
+
+vint16m1_t
+test___riscv_vle16_v_i16m1_mu(vbool16_t mask,vint16m1_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m1_mu(mask,merge,base,32);
+}
+
+vint16m2_t
+test___riscv_vle16_v_i16m2_mu(vbool8_t mask,vint16m2_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m2_mu(mask,merge,base,32);
+}
+
+vint16m4_t
+test___riscv_vle16_v_i16m4_mu(vbool4_t mask,vint16m4_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m4_mu(mask,merge,base,32);
+}
+
+vint16m8_t
+test___riscv_vle16_v_i16m8_mu(vbool2_t mask,vint16m8_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m8_mu(mask,merge,base,32);
+}
+
+vuint16mf4_t
+test___riscv_vle16_v_u16mf4_mu(vbool64_t mask,vuint16mf4_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf4_mu(mask,merge,base,32);
+}
+
+vuint16mf2_t
+test___riscv_vle16_v_u16mf2_mu(vbool32_t mask,vuint16mf2_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf2_mu(mask,merge,base,32);
+}
+
+vuint16m1_t
+test___riscv_vle16_v_u16m1_mu(vbool16_t mask,vuint16m1_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m1_mu(mask,merge,base,32);
+}
+
+vuint16m2_t
+test___riscv_vle16_v_u16m2_mu(vbool8_t mask,vuint16m2_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m2_mu(mask,merge,base,32);
+}
+
+vuint16m4_t
+test___riscv_vle16_v_u16m4_mu(vbool4_t mask,vuint16m4_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m4_mu(mask,merge,base,32);
+}
+
+vuint16m8_t
+test___riscv_vle16_v_u16m8_mu(vbool2_t mask,vuint16m8_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m8_mu(mask,merge,base,32);
+}
+
+vint32mf2_t
+test___riscv_vle32_v_i32mf2_mu(vbool64_t mask,vint32mf2_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32mf2_mu(mask,merge,base,32);
+}
+
+vint32m1_t
+test___riscv_vle32_v_i32m1_mu(vbool32_t mask,vint32m1_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m1_mu(mask,merge,base,32);
+}
+
+vint32m2_t
+test___riscv_vle32_v_i32m2_mu(vbool16_t mask,vint32m2_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m2_mu(mask,merge,base,32);
+}
+
+vint32m4_t
+test___riscv_vle32_v_i32m4_mu(vbool8_t mask,vint32m4_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m4_mu(mask,merge,base,32);
+}
+
+vint32m8_t
+test___riscv_vle32_v_i32m8_mu(vbool4_t mask,vint32m8_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m8_mu(mask,merge,base,32);
+}
+
+vuint32mf2_t
+test___riscv_vle32_v_u32mf2_mu(vbool64_t mask,vuint32mf2_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32mf2_mu(mask,merge,base,32);
+}
+
+vuint32m1_t
+test___riscv_vle32_v_u32m1_mu(vbool32_t mask,vuint32m1_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m1_mu(mask,merge,base,32);
+}
+
+vuint32m2_t
+test___riscv_vle32_v_u32m2_mu(vbool16_t mask,vuint32m2_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m2_mu(mask,merge,base,32);
+}
+
+vuint32m4_t
+test___riscv_vle32_v_u32m4_mu(vbool8_t mask,vuint32m4_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m4_mu(mask,merge,base,32);
+}
+
+vuint32m8_t
+test___riscv_vle32_v_u32m8_mu(vbool4_t mask,vuint32m8_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m8_mu(mask,merge,base,32);
+}
+
+vfloat32mf2_t
+test___riscv_vle32_v_f32mf2_mu(vbool64_t mask,vfloat32mf2_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32mf2_mu(mask,merge,base,32);
+}
+
+vfloat32m1_t
+test___riscv_vle32_v_f32m1_mu(vbool32_t mask,vfloat32m1_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m1_mu(mask,merge,base,32);
+}
+
+vfloat32m2_t
+test___riscv_vle32_v_f32m2_mu(vbool16_t mask,vfloat32m2_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m2_mu(mask,merge,base,32);
+}
+
+vfloat32m4_t
+test___riscv_vle32_v_f32m4_mu(vbool8_t mask,vfloat32m4_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m4_mu(mask,merge,base,32);
+}
+
+vfloat32m8_t
+test___riscv_vle32_v_f32m8_mu(vbool4_t mask,vfloat32m8_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m8_mu(mask,merge,base,32);
+}
+vint64m1_t
+test___riscv_vle64_v_i64m1_mu(vbool64_t mask,vint64m1_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m1_mu(mask,merge,base,32);
+}
+
+vint64m2_t
+test___riscv_vle64_v_i64m2_mu(vbool32_t mask,vint64m2_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m2_mu(mask,merge,base,32);
+}
+
+vint64m4_t
+test___riscv_vle64_v_i64m4_mu(vbool16_t mask,vint64m4_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m4_mu(mask,merge,base,32);
+}
+
+vint64m8_t
+test___riscv_vle64_v_i64m8_mu(vbool8_t mask,vint64m8_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m8_mu(mask,merge,base,32);
+}
+
+vuint64m1_t
+test___riscv_vle64_v_u64m1_mu(vbool64_t mask,vuint64m1_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m1_mu(mask,merge,base,32);
+}
+
+vuint64m2_t
+test___riscv_vle64_v_u64m2_mu(vbool32_t mask,vuint64m2_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m2_mu(mask,merge,base,32);
+}
+
+vuint64m4_t
+test___riscv_vle64_v_u64m4_mu(vbool16_t mask,vuint64m4_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m4_mu(mask,merge,base,32);
+}
+
+vuint64m8_t
+test___riscv_vle64_v_u64m8_mu(vbool8_t mask,vuint64m8_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m8_mu(mask,merge,base,32);
+}
+
+vfloat64m1_t
+test___riscv_vle64_v_f64m1_mu(vbool64_t mask,vfloat64m1_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m1_mu(mask,merge,base,32);
+}
+
+vfloat64m2_t
+test___riscv_vle64_v_f64m2_mu(vbool32_t mask,vfloat64m2_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m2_mu(mask,merge,base,32);
+}
+
+vfloat64m4_t
+test___riscv_vle64_v_f64m4_mu(vbool16_t mask,vfloat64m4_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m4_mu(mask,merge,base,32);
+}
+
+vfloat64m8_t
+test___riscv_vle64_v_f64m8_mu(vbool8_t mask,vfloat64m8_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m8_mu(mask,merge,base,32);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*mu\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vle_tu-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vle_tu-1.c
new file mode 100644
index 0000000..2f55f6a
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vle_tu-1.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vle8_v_i8mf8_tu(vint8mf8_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf8_tu(merge,base,vl);
+}
+
+vint8mf4_t
+test___riscv_vle8_v_i8mf4_tu(vint8mf4_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf4_tu(merge,base,vl);
+}
+
+vint8mf2_t
+test___riscv_vle8_v_i8mf2_tu(vint8mf2_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf2_tu(merge,base,vl);
+}
+
+vint8m1_t
+test___riscv_vle8_v_i8m1_tu(vint8m1_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m1_tu(merge,base,vl);
+}
+
+vint8m2_t
+test___riscv_vle8_v_i8m2_tu(vint8m2_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m2_tu(merge,base,vl);
+}
+
+vint8m4_t
+test___riscv_vle8_v_i8m4_tu(vint8m4_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m4_tu(merge,base,vl);
+}
+
+vint8m8_t
+test___riscv_vle8_v_i8m8_tu(vint8m8_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m8_tu(merge,base,vl);
+}
+
+vuint8mf8_t
+test___riscv_vle8_v_u8mf8_tu(vuint8mf8_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf8_tu(merge,base,vl);
+}
+
+vuint8mf4_t
+test___riscv_vle8_v_u8mf4_tu(vuint8mf4_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf4_tu(merge,base,vl);
+}
+
+vuint8mf2_t
+test___riscv_vle8_v_u8mf2_tu(vuint8mf2_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf2_tu(merge,base,vl);
+}
+
+vuint8m1_t
+test___riscv_vle8_v_u8m1_tu(vuint8m1_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m1_tu(merge,base,vl);
+}
+
+vuint8m2_t
+test___riscv_vle8_v_u8m2_tu(vuint8m2_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m2_tu(merge,base,vl);
+}
+
+vuint8m4_t
+test___riscv_vle8_v_u8m4_tu(vuint8m4_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m4_tu(merge,base,vl);
+}
+
+vuint8m8_t
+test___riscv_vle8_v_u8m8_tu(vuint8m8_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m8_tu(merge,base,vl);
+}
+
+vint16mf4_t
+test___riscv_vle16_v_i16mf4_tu(vint16mf4_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf4_tu(merge,base,vl);
+}
+
+vint16mf2_t
+test___riscv_vle16_v_i16mf2_tu(vint16mf2_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf2_tu(merge,base,vl);
+}
+
+vint16m1_t
+test___riscv_vle16_v_i16m1_tu(vint16m1_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m1_tu(merge,base,vl);
+}
+
+vint16m2_t
+test___riscv_vle16_v_i16m2_tu(vint16m2_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m2_tu(merge,base,vl);
+}
+
+vint16m4_t
+test___riscv_vle16_v_i16m4_tu(vint16m4_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m4_tu(merge,base,vl);
+}
+
+vint16m8_t
+test___riscv_vle16_v_i16m8_tu(vint16m8_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m8_tu(merge,base,vl);
+}
+
+vuint16mf4_t
+test___riscv_vle16_v_u16mf4_tu(vuint16mf4_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf4_tu(merge,base,vl);
+}
+
+vuint16mf2_t
+test___riscv_vle16_v_u16mf2_tu(vuint16mf2_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf2_tu(merge,base,vl);
+}
+
+vuint16m1_t
+test___riscv_vle16_v_u16m1_tu(vuint16m1_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m1_tu(merge,base,vl);
+}
+
+vuint16m2_t
+test___riscv_vle16_v_u16m2_tu(vuint16m2_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m2_tu(merge,base,vl);
+}
+
+vuint16m4_t
+test___riscv_vle16_v_u16m4_tu(vuint16m4_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m4_tu(merge,base,vl);
+}
+
+vuint16m8_t
+test___riscv_vle16_v_u16m8_tu(vuint16m8_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m8_tu(merge,base,vl);
+}
+
+vint32mf2_t
+test___riscv_vle32_v_i32mf2_tu(vint32mf2_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32mf2_tu(merge,base,vl);
+}
+
+vint32m1_t
+test___riscv_vle32_v_i32m1_tu(vint32m1_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m1_tu(merge,base,vl);
+}
+
+vint32m2_t
+test___riscv_vle32_v_i32m2_tu(vint32m2_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m2_tu(merge,base,vl);
+}
+
+vint32m4_t
+test___riscv_vle32_v_i32m4_tu(vint32m4_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m4_tu(merge,base,vl);
+}
+
+vint32m8_t
+test___riscv_vle32_v_i32m8_tu(vint32m8_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m8_tu(merge,base,vl);
+}
+
+vuint32mf2_t
+test___riscv_vle32_v_u32mf2_tu(vuint32mf2_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32mf2_tu(merge,base,vl);
+}
+
+vuint32m1_t
+test___riscv_vle32_v_u32m1_tu(vuint32m1_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m1_tu(merge,base,vl);
+}
+
+vuint32m2_t
+test___riscv_vle32_v_u32m2_tu(vuint32m2_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m2_tu(merge,base,vl);
+}
+
+vuint32m4_t
+test___riscv_vle32_v_u32m4_tu(vuint32m4_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m4_tu(merge,base,vl);
+}
+
+vuint32m8_t
+test___riscv_vle32_v_u32m8_tu(vuint32m8_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m8_tu(merge,base,vl);
+}
+
+vfloat32mf2_t
+test___riscv_vle32_v_f32mf2_tu(vfloat32mf2_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32mf2_tu(merge,base,vl);
+}
+
+vfloat32m1_t
+test___riscv_vle32_v_f32m1_tu(vfloat32m1_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m1_tu(merge,base,vl);
+}
+
+vfloat32m2_t
+test___riscv_vle32_v_f32m2_tu(vfloat32m2_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m2_tu(merge,base,vl);
+}
+
+vfloat32m4_t
+test___riscv_vle32_v_f32m4_tu(vfloat32m4_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m4_tu(merge,base,vl);
+}
+
+vfloat32m8_t
+test___riscv_vle32_v_f32m8_tu(vfloat32m8_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m8_tu(merge,base,vl);
+}
+
+vint64m1_t
+test___riscv_vle64_v_i64m1_tu(vint64m1_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m1_tu(merge,base,vl);
+}
+
+vint64m2_t
+test___riscv_vle64_v_i64m2_tu(vint64m2_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m2_tu(merge,base,vl);
+}
+
+vint64m4_t
+test___riscv_vle64_v_i64m4_tu(vint64m4_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m4_tu(merge,base,vl);
+}
+
+vint64m8_t
+test___riscv_vle64_v_i64m8_tu(vint64m8_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m8_tu(merge,base,vl);
+}
+
+vuint64m1_t
+test___riscv_vle64_v_u64m1_tu(vuint64m1_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m1_tu(merge,base,vl);
+}
+
+vuint64m2_t
+test___riscv_vle64_v_u64m2_tu(vuint64m2_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m2_tu(merge,base,vl);
+}
+
+vuint64m4_t
+test___riscv_vle64_v_u64m4_tu(vuint64m4_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m4_tu(merge,base,vl);
+}
+
+vuint64m8_t
+test___riscv_vle64_v_u64m8_tu(vuint64m8_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m8_tu(merge,base,vl);
+}
+
+vfloat64m1_t
+test___riscv_vle64_v_f64m1_tu(vfloat64m1_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m1_tu(merge,base,vl);
+}
+
+vfloat64m2_t
+test___riscv_vle64_v_f64m2_tu(vfloat64m2_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m2_tu(merge,base,vl);
+}
+
+vfloat64m4_t
+test___riscv_vle64_v_f64m4_tu(vfloat64m4_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m4_tu(merge,base,vl);
+}
+
+vfloat64m8_t
+test___riscv_vle64_v_f64m8_tu(vfloat64m8_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m8_tu(merge,base,vl);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vle_tu-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vle_tu-2.c
new file mode 100644
index 0000000..6717356
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vle_tu-2.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vle8_v_i8mf8_tu(vint8mf8_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf8_tu(merge,base,31);
+}
+
+vint8mf4_t
+test___riscv_vle8_v_i8mf4_tu(vint8mf4_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf4_tu(merge,base,31);
+}
+
+vint8mf2_t
+test___riscv_vle8_v_i8mf2_tu(vint8mf2_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf2_tu(merge,base,31);
+}
+
+vint8m1_t
+test___riscv_vle8_v_i8m1_tu(vint8m1_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m1_tu(merge,base,31);
+}
+
+vint8m2_t
+test___riscv_vle8_v_i8m2_tu(vint8m2_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m2_tu(merge,base,31);
+}
+
+vint8m4_t
+test___riscv_vle8_v_i8m4_tu(vint8m4_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m4_tu(merge,base,31);
+}
+
+vint8m8_t
+test___riscv_vle8_v_i8m8_tu(vint8m8_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m8_tu(merge,base,31);
+}
+
+vuint8mf8_t
+test___riscv_vle8_v_u8mf8_tu(vuint8mf8_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf8_tu(merge,base,31);
+}
+
+vuint8mf4_t
+test___riscv_vle8_v_u8mf4_tu(vuint8mf4_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf4_tu(merge,base,31);
+}
+
+vuint8mf2_t
+test___riscv_vle8_v_u8mf2_tu(vuint8mf2_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf2_tu(merge,base,31);
+}
+
+vuint8m1_t
+test___riscv_vle8_v_u8m1_tu(vuint8m1_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m1_tu(merge,base,31);
+}
+
+vuint8m2_t
+test___riscv_vle8_v_u8m2_tu(vuint8m2_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m2_tu(merge,base,31);
+}
+
+vuint8m4_t
+test___riscv_vle8_v_u8m4_tu(vuint8m4_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m4_tu(merge,base,31);
+}
+
+vuint8m8_t
+test___riscv_vle8_v_u8m8_tu(vuint8m8_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m8_tu(merge,base,31);
+}
+
+vint16mf4_t
+test___riscv_vle16_v_i16mf4_tu(vint16mf4_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf4_tu(merge,base,31);
+}
+
+vint16mf2_t
+test___riscv_vle16_v_i16mf2_tu(vint16mf2_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf2_tu(merge,base,31);
+}
+
+vint16m1_t
+test___riscv_vle16_v_i16m1_tu(vint16m1_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m1_tu(merge,base,31);
+}
+
+vint16m2_t
+test___riscv_vle16_v_i16m2_tu(vint16m2_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m2_tu(merge,base,31);
+}
+
+vint16m4_t
+test___riscv_vle16_v_i16m4_tu(vint16m4_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m4_tu(merge,base,31);
+}
+
+vint16m8_t
+test___riscv_vle16_v_i16m8_tu(vint16m8_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m8_tu(merge,base,31);
+}
+
+vuint16mf4_t
+test___riscv_vle16_v_u16mf4_tu(vuint16mf4_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf4_tu(merge,base,31);
+}
+
+vuint16mf2_t
+test___riscv_vle16_v_u16mf2_tu(vuint16mf2_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf2_tu(merge,base,31);
+}
+
+vuint16m1_t
+test___riscv_vle16_v_u16m1_tu(vuint16m1_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m1_tu(merge,base,31);
+}
+
+vuint16m2_t
+test___riscv_vle16_v_u16m2_tu(vuint16m2_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m2_tu(merge,base,31);
+}
+
+vuint16m4_t
+test___riscv_vle16_v_u16m4_tu(vuint16m4_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m4_tu(merge,base,31);
+}
+
+vuint16m8_t
+test___riscv_vle16_v_u16m8_tu(vuint16m8_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m8_tu(merge,base,31);
+}
+
+vint32mf2_t
+test___riscv_vle32_v_i32mf2_tu(vint32mf2_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32mf2_tu(merge,base,31);
+}
+
+vint32m1_t
+test___riscv_vle32_v_i32m1_tu(vint32m1_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m1_tu(merge,base,31);
+}
+
+vint32m2_t
+test___riscv_vle32_v_i32m2_tu(vint32m2_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m2_tu(merge,base,31);
+}
+
+vint32m4_t
+test___riscv_vle32_v_i32m4_tu(vint32m4_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m4_tu(merge,base,31);
+}
+
+vint32m8_t
+test___riscv_vle32_v_i32m8_tu(vint32m8_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m8_tu(merge,base,31);
+}
+
+vuint32mf2_t
+test___riscv_vle32_v_u32mf2_tu(vuint32mf2_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32mf2_tu(merge,base,31);
+}
+
+vuint32m1_t
+test___riscv_vle32_v_u32m1_tu(vuint32m1_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m1_tu(merge,base,31);
+}
+
+vuint32m2_t
+test___riscv_vle32_v_u32m2_tu(vuint32m2_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m2_tu(merge,base,31);
+}
+
+vuint32m4_t
+test___riscv_vle32_v_u32m4_tu(vuint32m4_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m4_tu(merge,base,31);
+}
+
+vuint32m8_t
+test___riscv_vle32_v_u32m8_tu(vuint32m8_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m8_tu(merge,base,31);
+}
+
+vfloat32mf2_t
+test___riscv_vle32_v_f32mf2_tu(vfloat32mf2_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32mf2_tu(merge,base,31);
+}
+
+vfloat32m1_t
+test___riscv_vle32_v_f32m1_tu(vfloat32m1_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m1_tu(merge,base,31);
+}
+
+vfloat32m2_t
+test___riscv_vle32_v_f32m2_tu(vfloat32m2_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m2_tu(merge,base,31);
+}
+
+vfloat32m4_t
+test___riscv_vle32_v_f32m4_tu(vfloat32m4_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m4_tu(merge,base,31);
+}
+
+vfloat32m8_t
+test___riscv_vle32_v_f32m8_tu(vfloat32m8_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m8_tu(merge,base,31);
+}
+
+vint64m1_t
+test___riscv_vle64_v_i64m1_tu(vint64m1_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m1_tu(merge,base,31);
+}
+
+vint64m2_t
+test___riscv_vle64_v_i64m2_tu(vint64m2_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m2_tu(merge,base,31);
+}
+
+vint64m4_t
+test___riscv_vle64_v_i64m4_tu(vint64m4_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m4_tu(merge,base,31);
+}
+
+vint64m8_t
+test___riscv_vle64_v_i64m8_tu(vint64m8_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m8_tu(merge,base,31);
+}
+
+vuint64m1_t
+test___riscv_vle64_v_u64m1_tu(vuint64m1_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m1_tu(merge,base,31);
+}
+
+vuint64m2_t
+test___riscv_vle64_v_u64m2_tu(vuint64m2_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m2_tu(merge,base,31);
+}
+
+vuint64m4_t
+test___riscv_vle64_v_u64m4_tu(vuint64m4_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m4_tu(merge,base,31);
+}
+
+vuint64m8_t
+test___riscv_vle64_v_u64m8_tu(vuint64m8_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m8_tu(merge,base,31);
+}
+
+vfloat64m1_t
+test___riscv_vle64_v_f64m1_tu(vfloat64m1_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m1_tu(merge,base,31);
+}
+
+vfloat64m2_t
+test___riscv_vle64_v_f64m2_tu(vfloat64m2_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m2_tu(merge,base,31);
+}
+
+vfloat64m4_t
+test___riscv_vle64_v_f64m4_tu(vfloat64m4_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m4_tu(merge,base,31);
+}
+
+vfloat64m8_t
+test___riscv_vle64_v_f64m8_tu(vfloat64m8_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m8_tu(merge,base,31);
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vle_tu-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vle_tu-3.c
new file mode 100644
index 0000000..2becefe
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vle_tu-3.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vle8_v_i8mf8_tu(vint8mf8_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf8_tu(merge,base,32);
+}
+
+vint8mf4_t
+test___riscv_vle8_v_i8mf4_tu(vint8mf4_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf4_tu(merge,base,32);
+}
+
+vint8mf2_t
+test___riscv_vle8_v_i8mf2_tu(vint8mf2_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf2_tu(merge,base,32);
+}
+
+vint8m1_t
+test___riscv_vle8_v_i8m1_tu(vint8m1_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m1_tu(merge,base,32);
+}
+
+vint8m2_t
+test___riscv_vle8_v_i8m2_tu(vint8m2_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m2_tu(merge,base,32);
+}
+
+vint8m4_t
+test___riscv_vle8_v_i8m4_tu(vint8m4_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m4_tu(merge,base,32);
+}
+
+vint8m8_t
+test___riscv_vle8_v_i8m8_tu(vint8m8_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m8_tu(merge,base,32);
+}
+
+vuint8mf8_t
+test___riscv_vle8_v_u8mf8_tu(vuint8mf8_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf8_tu(merge,base,32);
+}
+
+vuint8mf4_t
+test___riscv_vle8_v_u8mf4_tu(vuint8mf4_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf4_tu(merge,base,32);
+}
+
+vuint8mf2_t
+test___riscv_vle8_v_u8mf2_tu(vuint8mf2_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf2_tu(merge,base,32);
+}
+
+vuint8m1_t
+test___riscv_vle8_v_u8m1_tu(vuint8m1_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m1_tu(merge,base,32);
+}
+
+vuint8m2_t
+test___riscv_vle8_v_u8m2_tu(vuint8m2_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m2_tu(merge,base,32);
+}
+
+vuint8m4_t
+test___riscv_vle8_v_u8m4_tu(vuint8m4_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m4_tu(merge,base,32);
+}
+
+vuint8m8_t
+test___riscv_vle8_v_u8m8_tu(vuint8m8_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m8_tu(merge,base,32);
+}
+
+vint16mf4_t
+test___riscv_vle16_v_i16mf4_tu(vint16mf4_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf4_tu(merge,base,32);
+}
+
+vint16mf2_t
+test___riscv_vle16_v_i16mf2_tu(vint16mf2_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf2_tu(merge,base,32);
+}
+
+vint16m1_t
+test___riscv_vle16_v_i16m1_tu(vint16m1_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m1_tu(merge,base,32);
+}
+
+vint16m2_t
+test___riscv_vle16_v_i16m2_tu(vint16m2_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m2_tu(merge,base,32);
+}
+
+vint16m4_t
+test___riscv_vle16_v_i16m4_tu(vint16m4_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m4_tu(merge,base,32);
+}
+
+vint16m8_t
+test___riscv_vle16_v_i16m8_tu(vint16m8_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m8_tu(merge,base,32);
+}
+
+vuint16mf4_t
+test___riscv_vle16_v_u16mf4_tu(vuint16mf4_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf4_tu(merge,base,32);
+}
+
+vuint16mf2_t
+test___riscv_vle16_v_u16mf2_tu(vuint16mf2_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf2_tu(merge,base,32);
+}
+
+vuint16m1_t
+test___riscv_vle16_v_u16m1_tu(vuint16m1_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m1_tu(merge,base,32);
+}
+
+vuint16m2_t
+test___riscv_vle16_v_u16m2_tu(vuint16m2_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m2_tu(merge,base,32);
+}
+
+vuint16m4_t
+test___riscv_vle16_v_u16m4_tu(vuint16m4_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m4_tu(merge,base,32);
+}
+
+vuint16m8_t
+test___riscv_vle16_v_u16m8_tu(vuint16m8_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m8_tu(merge,base,32);
+}
+
+vint32mf2_t
+test___riscv_vle32_v_i32mf2_tu(vint32mf2_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32mf2_tu(merge,base,32);
+}
+
+vint32m1_t
+test___riscv_vle32_v_i32m1_tu(vint32m1_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m1_tu(merge,base,32);
+}
+
+vint32m2_t
+test___riscv_vle32_v_i32m2_tu(vint32m2_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m2_tu(merge,base,32);
+}
+
+vint32m4_t
+test___riscv_vle32_v_i32m4_tu(vint32m4_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m4_tu(merge,base,32);
+}
+
+vint32m8_t
+test___riscv_vle32_v_i32m8_tu(vint32m8_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m8_tu(merge,base,32);
+}
+
+vuint32mf2_t
+test___riscv_vle32_v_u32mf2_tu(vuint32mf2_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32mf2_tu(merge,base,32);
+}
+
+vuint32m1_t
+test___riscv_vle32_v_u32m1_tu(vuint32m1_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m1_tu(merge,base,32);
+}
+
+vuint32m2_t
+test___riscv_vle32_v_u32m2_tu(vuint32m2_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m2_tu(merge,base,32);
+}
+
+vuint32m4_t
+test___riscv_vle32_v_u32m4_tu(vuint32m4_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m4_tu(merge,base,32);
+}
+
+vuint32m8_t
+test___riscv_vle32_v_u32m8_tu(vuint32m8_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m8_tu(merge,base,32);
+}
+
+vfloat32mf2_t
+test___riscv_vle32_v_f32mf2_tu(vfloat32mf2_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32mf2_tu(merge,base,32);
+}
+
+vfloat32m1_t
+test___riscv_vle32_v_f32m1_tu(vfloat32m1_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m1_tu(merge,base,32);
+}
+
+vfloat32m2_t
+test___riscv_vle32_v_f32m2_tu(vfloat32m2_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m2_tu(merge,base,32);
+}
+
+vfloat32m4_t
+test___riscv_vle32_v_f32m4_tu(vfloat32m4_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m4_tu(merge,base,32);
+}
+
+vfloat32m8_t
+test___riscv_vle32_v_f32m8_tu(vfloat32m8_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m8_tu(merge,base,32);
+}
+
+vint64m1_t
+test___riscv_vle64_v_i64m1_tu(vint64m1_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m1_tu(merge,base,32);
+}
+
+vint64m2_t
+test___riscv_vle64_v_i64m2_tu(vint64m2_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m2_tu(merge,base,32);
+}
+
+vint64m4_t
+test___riscv_vle64_v_i64m4_tu(vint64m4_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m4_tu(merge,base,32);
+}
+
+vint64m8_t
+test___riscv_vle64_v_i64m8_tu(vint64m8_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m8_tu(merge,base,32);
+}
+
+vuint64m1_t
+test___riscv_vle64_v_u64m1_tu(vuint64m1_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m1_tu(merge,base,32);
+}
+
+vuint64m2_t
+test___riscv_vle64_v_u64m2_tu(vuint64m2_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m2_tu(merge,base,32);
+}
+
+vuint64m4_t
+test___riscv_vle64_v_u64m4_tu(vuint64m4_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m4_tu(merge,base,32);
+}
+
+vuint64m8_t
+test___riscv_vle64_v_u64m8_tu(vuint64m8_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m8_tu(merge,base,32);
+}
+
+vfloat64m1_t
+test___riscv_vle64_v_f64m1_tu(vfloat64m1_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m1_tu(merge,base,32);
+}
+
+vfloat64m2_t
+test___riscv_vle64_v_f64m2_tu(vfloat64m2_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m2_tu(merge,base,32);
+}
+
+vfloat64m4_t
+test___riscv_vle64_v_f64m4_tu(vfloat64m4_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m4_tu(merge,base,32);
+}
+
+vfloat64m8_t
+test___riscv_vle64_v_f64m8_tu(vfloat64m8_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m8_tu(merge,base,32);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vle_tum-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vle_tum-1.c
new file mode 100644
index 0000000..ae2606d
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vle_tum-1.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vle8_v_i8mf8_tum(vbool64_t mask,vint8mf8_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf8_tum(mask,merge,base,vl);
+}
+
+vint8mf4_t
+test___riscv_vle8_v_i8mf4_tum(vbool32_t mask,vint8mf4_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf4_tum(mask,merge,base,vl);
+}
+
+vint8mf2_t
+test___riscv_vle8_v_i8mf2_tum(vbool16_t mask,vint8mf2_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf2_tum(mask,merge,base,vl);
+}
+
+vint8m1_t
+test___riscv_vle8_v_i8m1_tum(vbool8_t mask,vint8m1_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m1_tum(mask,merge,base,vl);
+}
+
+vint8m2_t
+test___riscv_vle8_v_i8m2_tum(vbool4_t mask,vint8m2_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m2_tum(mask,merge,base,vl);
+}
+
+vint8m4_t
+test___riscv_vle8_v_i8m4_tum(vbool2_t mask,vint8m4_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m4_tum(mask,merge,base,vl);
+}
+
+vint8m8_t
+test___riscv_vle8_v_i8m8_tum(vbool1_t mask,vint8m8_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m8_tum(mask,merge,base,vl);
+}
+
+vuint8mf8_t
+test___riscv_vle8_v_u8mf8_tum(vbool64_t mask,vuint8mf8_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf8_tum(mask,merge,base,vl);
+}
+
+vuint8mf4_t
+test___riscv_vle8_v_u8mf4_tum(vbool32_t mask,vuint8mf4_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf4_tum(mask,merge,base,vl);
+}
+
+vuint8mf2_t
+test___riscv_vle8_v_u8mf2_tum(vbool16_t mask,vuint8mf2_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf2_tum(mask,merge,base,vl);
+}
+
+vuint8m1_t
+test___riscv_vle8_v_u8m1_tum(vbool8_t mask,vuint8m1_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m1_tum(mask,merge,base,vl);
+}
+
+vuint8m2_t
+test___riscv_vle8_v_u8m2_tum(vbool4_t mask,vuint8m2_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m2_tum(mask,merge,base,vl);
+}
+
+vuint8m4_t
+test___riscv_vle8_v_u8m4_tum(vbool2_t mask,vuint8m4_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m4_tum(mask,merge,base,vl);
+}
+
+vuint8m8_t
+test___riscv_vle8_v_u8m8_tum(vbool1_t mask,vuint8m8_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m8_tum(mask,merge,base,vl);
+}
+
+vint16mf4_t
+test___riscv_vle16_v_i16mf4_tum(vbool64_t mask,vint16mf4_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf4_tum(mask,merge,base,vl);
+}
+
+vint16mf2_t
+test___riscv_vle16_v_i16mf2_tum(vbool32_t mask,vint16mf2_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf2_tum(mask,merge,base,vl);
+}
+
+vint16m1_t
+test___riscv_vle16_v_i16m1_tum(vbool16_t mask,vint16m1_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m1_tum(mask,merge,base,vl);
+}
+
+vint16m2_t
+test___riscv_vle16_v_i16m2_tum(vbool8_t mask,vint16m2_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m2_tum(mask,merge,base,vl);
+}
+
+vint16m4_t
+test___riscv_vle16_v_i16m4_tum(vbool4_t mask,vint16m4_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m4_tum(mask,merge,base,vl);
+}
+
+vint16m8_t
+test___riscv_vle16_v_i16m8_tum(vbool2_t mask,vint16m8_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m8_tum(mask,merge,base,vl);
+}
+
+vuint16mf4_t
+test___riscv_vle16_v_u16mf4_tum(vbool64_t mask,vuint16mf4_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf4_tum(mask,merge,base,vl);
+}
+
+vuint16mf2_t
+test___riscv_vle16_v_u16mf2_tum(vbool32_t mask,vuint16mf2_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf2_tum(mask,merge,base,vl);
+}
+
+vuint16m1_t
+test___riscv_vle16_v_u16m1_tum(vbool16_t mask,vuint16m1_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m1_tum(mask,merge,base,vl);
+}
+
+vuint16m2_t
+test___riscv_vle16_v_u16m2_tum(vbool8_t mask,vuint16m2_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m2_tum(mask,merge,base,vl);
+}
+
+vuint16m4_t
+test___riscv_vle16_v_u16m4_tum(vbool4_t mask,vuint16m4_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m4_tum(mask,merge,base,vl);
+}
+
+vuint16m8_t
+test___riscv_vle16_v_u16m8_tum(vbool2_t mask,vuint16m8_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m8_tum(mask,merge,base,vl);
+}
+
+vint32mf2_t
+test___riscv_vle32_v_i32mf2_tum(vbool64_t mask,vint32mf2_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32mf2_tum(mask,merge,base,vl);
+}
+
+vint32m1_t
+test___riscv_vle32_v_i32m1_tum(vbool32_t mask,vint32m1_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m1_tum(mask,merge,base,vl);
+}
+
+vint32m2_t
+test___riscv_vle32_v_i32m2_tum(vbool16_t mask,vint32m2_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m2_tum(mask,merge,base,vl);
+}
+
+vint32m4_t
+test___riscv_vle32_v_i32m4_tum(vbool8_t mask,vint32m4_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m4_tum(mask,merge,base,vl);
+}
+
+vint32m8_t
+test___riscv_vle32_v_i32m8_tum(vbool4_t mask,vint32m8_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m8_tum(mask,merge,base,vl);
+}
+
+vuint32mf2_t
+test___riscv_vle32_v_u32mf2_tum(vbool64_t mask,vuint32mf2_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32mf2_tum(mask,merge,base,vl);
+}
+
+vuint32m1_t
+test___riscv_vle32_v_u32m1_tum(vbool32_t mask,vuint32m1_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m1_tum(mask,merge,base,vl);
+}
+
+vuint32m2_t
+test___riscv_vle32_v_u32m2_tum(vbool16_t mask,vuint32m2_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m2_tum(mask,merge,base,vl);
+}
+
+vuint32m4_t
+test___riscv_vle32_v_u32m4_tum(vbool8_t mask,vuint32m4_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m4_tum(mask,merge,base,vl);
+}
+
+vuint32m8_t
+test___riscv_vle32_v_u32m8_tum(vbool4_t mask,vuint32m8_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m8_tum(mask,merge,base,vl);
+}
+
+vfloat32mf2_t
+test___riscv_vle32_v_f32mf2_tum(vbool64_t mask,vfloat32mf2_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32mf2_tum(mask,merge,base,vl);
+}
+
+vfloat32m1_t
+test___riscv_vle32_v_f32m1_tum(vbool32_t mask,vfloat32m1_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m1_tum(mask,merge,base,vl);
+}
+
+vfloat32m2_t
+test___riscv_vle32_v_f32m2_tum(vbool16_t mask,vfloat32m2_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m2_tum(mask,merge,base,vl);
+}
+
+vfloat32m4_t
+test___riscv_vle32_v_f32m4_tum(vbool8_t mask,vfloat32m4_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m4_tum(mask,merge,base,vl);
+}
+
+vfloat32m8_t
+test___riscv_vle32_v_f32m8_tum(vbool4_t mask,vfloat32m8_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m8_tum(mask,merge,base,vl);
+}
+
+vint64m1_t
+test___riscv_vle64_v_i64m1_tum(vbool64_t mask,vint64m1_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m1_tum(mask,merge,base,vl);
+}
+
+vint64m2_t
+test___riscv_vle64_v_i64m2_tum(vbool32_t mask,vint64m2_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m2_tum(mask,merge,base,vl);
+}
+
+vint64m4_t
+test___riscv_vle64_v_i64m4_tum(vbool16_t mask,vint64m4_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m4_tum(mask,merge,base,vl);
+}
+
+vint64m8_t
+test___riscv_vle64_v_i64m8_tum(vbool8_t mask,vint64m8_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m8_tum(mask,merge,base,vl);
+}
+
+vuint64m1_t
+test___riscv_vle64_v_u64m1_tum(vbool64_t mask,vuint64m1_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m1_tum(mask,merge,base,vl);
+}
+
+vuint64m2_t
+test___riscv_vle64_v_u64m2_tum(vbool32_t mask,vuint64m2_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m2_tum(mask,merge,base,vl);
+}
+
+vuint64m4_t
+test___riscv_vle64_v_u64m4_tum(vbool16_t mask,vuint64m4_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m4_tum(mask,merge,base,vl);
+}
+
+vuint64m8_t
+test___riscv_vle64_v_u64m8_tum(vbool8_t mask,vuint64m8_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m8_tum(mask,merge,base,vl);
+}
+
+vfloat64m1_t
+test___riscv_vle64_v_f64m1_tum(vbool64_t mask,vfloat64m1_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m1_tum(mask,merge,base,vl);
+}
+
+vfloat64m2_t
+test___riscv_vle64_v_f64m2_tum(vbool32_t mask,vfloat64m2_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m2_tum(mask,merge,base,vl);
+}
+
+vfloat64m4_t
+test___riscv_vle64_v_f64m4_tum(vbool16_t mask,vfloat64m4_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m4_tum(mask,merge,base,vl);
+}
+
+vfloat64m8_t
+test___riscv_vle64_v_f64m8_tum(vbool8_t mask,vfloat64m8_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m8_tum(mask,merge,base,vl);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vle_tum-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vle_tum-2.c
new file mode 100644
index 0000000..ec697be
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vle_tum-2.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vle8_v_i8mf8_tum(vbool64_t mask,vint8mf8_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf8_tum(mask,merge,base,31);
+}
+
+vint8mf4_t
+test___riscv_vle8_v_i8mf4_tum(vbool32_t mask,vint8mf4_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf4_tum(mask,merge,base,31);
+}
+
+vint8mf2_t
+test___riscv_vle8_v_i8mf2_tum(vbool16_t mask,vint8mf2_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf2_tum(mask,merge,base,31);
+}
+
+vint8m1_t
+test___riscv_vle8_v_i8m1_tum(vbool8_t mask,vint8m1_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m1_tum(mask,merge,base,31);
+}
+
+vint8m2_t
+test___riscv_vle8_v_i8m2_tum(vbool4_t mask,vint8m2_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m2_tum(mask,merge,base,31);
+}
+
+vint8m4_t
+test___riscv_vle8_v_i8m4_tum(vbool2_t mask,vint8m4_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m4_tum(mask,merge,base,31);
+}
+
+vint8m8_t
+test___riscv_vle8_v_i8m8_tum(vbool1_t mask,vint8m8_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m8_tum(mask,merge,base,31);
+}
+
+vuint8mf8_t
+test___riscv_vle8_v_u8mf8_tum(vbool64_t mask,vuint8mf8_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf8_tum(mask,merge,base,31);
+}
+
+vuint8mf4_t
+test___riscv_vle8_v_u8mf4_tum(vbool32_t mask,vuint8mf4_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf4_tum(mask,merge,base,31);
+}
+
+vuint8mf2_t
+test___riscv_vle8_v_u8mf2_tum(vbool16_t mask,vuint8mf2_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf2_tum(mask,merge,base,31);
+}
+
+vuint8m1_t
+test___riscv_vle8_v_u8m1_tum(vbool8_t mask,vuint8m1_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m1_tum(mask,merge,base,31);
+}
+
+vuint8m2_t
+test___riscv_vle8_v_u8m2_tum(vbool4_t mask,vuint8m2_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m2_tum(mask,merge,base,31);
+}
+
+vuint8m4_t
+test___riscv_vle8_v_u8m4_tum(vbool2_t mask,vuint8m4_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m4_tum(mask,merge,base,31);
+}
+
+vuint8m8_t
+test___riscv_vle8_v_u8m8_tum(vbool1_t mask,vuint8m8_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m8_tum(mask,merge,base,31);
+}
+
+vint16mf4_t
+test___riscv_vle16_v_i16mf4_tum(vbool64_t mask,vint16mf4_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf4_tum(mask,merge,base,31);
+}
+
+vint16mf2_t
+test___riscv_vle16_v_i16mf2_tum(vbool32_t mask,vint16mf2_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf2_tum(mask,merge,base,31);
+}
+
+vint16m1_t
+test___riscv_vle16_v_i16m1_tum(vbool16_t mask,vint16m1_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m1_tum(mask,merge,base,31);
+}
+
+vint16m2_t
+test___riscv_vle16_v_i16m2_tum(vbool8_t mask,vint16m2_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m2_tum(mask,merge,base,31);
+}
+
+vint16m4_t
+test___riscv_vle16_v_i16m4_tum(vbool4_t mask,vint16m4_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m4_tum(mask,merge,base,31);
+}
+
+vint16m8_t
+test___riscv_vle16_v_i16m8_tum(vbool2_t mask,vint16m8_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m8_tum(mask,merge,base,31);
+}
+
+vuint16mf4_t
+test___riscv_vle16_v_u16mf4_tum(vbool64_t mask,vuint16mf4_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf4_tum(mask,merge,base,31);
+}
+
+vuint16mf2_t
+test___riscv_vle16_v_u16mf2_tum(vbool32_t mask,vuint16mf2_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf2_tum(mask,merge,base,31);
+}
+
+vuint16m1_t
+test___riscv_vle16_v_u16m1_tum(vbool16_t mask,vuint16m1_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m1_tum(mask,merge,base,31);
+}
+
+vuint16m2_t
+test___riscv_vle16_v_u16m2_tum(vbool8_t mask,vuint16m2_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m2_tum(mask,merge,base,31);
+}
+
+vuint16m4_t
+test___riscv_vle16_v_u16m4_tum(vbool4_t mask,vuint16m4_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m4_tum(mask,merge,base,31);
+}
+
+vuint16m8_t
+test___riscv_vle16_v_u16m8_tum(vbool2_t mask,vuint16m8_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m8_tum(mask,merge,base,31);
+}
+
+vint32mf2_t
+test___riscv_vle32_v_i32mf2_tum(vbool64_t mask,vint32mf2_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32mf2_tum(mask,merge,base,31);
+}
+
+vint32m1_t
+test___riscv_vle32_v_i32m1_tum(vbool32_t mask,vint32m1_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m1_tum(mask,merge,base,31);
+}
+
+vint32m2_t
+test___riscv_vle32_v_i32m2_tum(vbool16_t mask,vint32m2_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m2_tum(mask,merge,base,31);
+}
+
+vint32m4_t
+test___riscv_vle32_v_i32m4_tum(vbool8_t mask,vint32m4_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m4_tum(mask,merge,base,31);
+}
+
+vint32m8_t
+test___riscv_vle32_v_i32m8_tum(vbool4_t mask,vint32m8_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m8_tum(mask,merge,base,31);
+}
+
+vuint32mf2_t
+test___riscv_vle32_v_u32mf2_tum(vbool64_t mask,vuint32mf2_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32mf2_tum(mask,merge,base,31);
+}
+
+vuint32m1_t
+test___riscv_vle32_v_u32m1_tum(vbool32_t mask,vuint32m1_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m1_tum(mask,merge,base,31);
+}
+
+vuint32m2_t
+test___riscv_vle32_v_u32m2_tum(vbool16_t mask,vuint32m2_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m2_tum(mask,merge,base,31);
+}
+
+vuint32m4_t
+test___riscv_vle32_v_u32m4_tum(vbool8_t mask,vuint32m4_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m4_tum(mask,merge,base,31);
+}
+
+vuint32m8_t
+test___riscv_vle32_v_u32m8_tum(vbool4_t mask,vuint32m8_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m8_tum(mask,merge,base,31);
+}
+
+vfloat32mf2_t
+test___riscv_vle32_v_f32mf2_tum(vbool64_t mask,vfloat32mf2_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32mf2_tum(mask,merge,base,31);
+}
+
+vfloat32m1_t
+test___riscv_vle32_v_f32m1_tum(vbool32_t mask,vfloat32m1_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m1_tum(mask,merge,base,31);
+}
+
+vfloat32m2_t
+test___riscv_vle32_v_f32m2_tum(vbool16_t mask,vfloat32m2_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m2_tum(mask,merge,base,31);
+}
+
+vfloat32m4_t
+test___riscv_vle32_v_f32m4_tum(vbool8_t mask,vfloat32m4_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m4_tum(mask,merge,base,31);
+}
+
+vfloat32m8_t
+test___riscv_vle32_v_f32m8_tum(vbool4_t mask,vfloat32m8_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m8_tum(mask,merge,base,31);
+}
+
+vint64m1_t
+test___riscv_vle64_v_i64m1_tum(vbool64_t mask,vint64m1_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m1_tum(mask,merge,base,31);
+}
+
+vint64m2_t
+test___riscv_vle64_v_i64m2_tum(vbool32_t mask,vint64m2_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m2_tum(mask,merge,base,31);
+}
+
+vint64m4_t
+test___riscv_vle64_v_i64m4_tum(vbool16_t mask,vint64m4_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m4_tum(mask,merge,base,31);
+}
+
+vint64m8_t
+test___riscv_vle64_v_i64m8_tum(vbool8_t mask,vint64m8_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m8_tum(mask,merge,base,31);
+}
+
+vuint64m1_t
+test___riscv_vle64_v_u64m1_tum(vbool64_t mask,vuint64m1_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m1_tum(mask,merge,base,31);
+}
+
+vuint64m2_t
+test___riscv_vle64_v_u64m2_tum(vbool32_t mask,vuint64m2_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m2_tum(mask,merge,base,31);
+}
+
+vuint64m4_t
+test___riscv_vle64_v_u64m4_tum(vbool16_t mask,vuint64m4_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m4_tum(mask,merge,base,31);
+}
+
+vuint64m8_t
+test___riscv_vle64_v_u64m8_tum(vbool8_t mask,vuint64m8_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m8_tum(mask,merge,base,31);
+}
+
+vfloat64m1_t
+test___riscv_vle64_v_f64m1_tum(vbool64_t mask,vfloat64m1_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m1_tum(mask,merge,base,31);
+}
+
+vfloat64m2_t
+test___riscv_vle64_v_f64m2_tum(vbool32_t mask,vfloat64m2_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m2_tum(mask,merge,base,31);
+}
+
+vfloat64m4_t
+test___riscv_vle64_v_f64m4_tum(vbool16_t mask,vfloat64m4_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m4_tum(mask,merge,base,31);
+}
+
+vfloat64m8_t
+test___riscv_vle64_v_f64m8_tum(vbool8_t mask,vfloat64m8_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m8_tum(mask,merge,base,31);
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vle_tum-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vle_tum-3.c
new file mode 100644
index 0000000..0a9fc78
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vle_tum-3.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vle8_v_i8mf8_tum(vbool64_t mask,vint8mf8_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf8_tum(mask,merge,base,32);
+}
+
+vint8mf4_t
+test___riscv_vle8_v_i8mf4_tum(vbool32_t mask,vint8mf4_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf4_tum(mask,merge,base,32);
+}
+
+vint8mf2_t
+test___riscv_vle8_v_i8mf2_tum(vbool16_t mask,vint8mf2_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf2_tum(mask,merge,base,32);
+}
+
+vint8m1_t
+test___riscv_vle8_v_i8m1_tum(vbool8_t mask,vint8m1_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m1_tum(mask,merge,base,32);
+}
+
+vint8m2_t
+test___riscv_vle8_v_i8m2_tum(vbool4_t mask,vint8m2_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m2_tum(mask,merge,base,32);
+}
+
+vint8m4_t
+test___riscv_vle8_v_i8m4_tum(vbool2_t mask,vint8m4_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m4_tum(mask,merge,base,32);
+}
+
+vint8m8_t
+test___riscv_vle8_v_i8m8_tum(vbool1_t mask,vint8m8_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m8_tum(mask,merge,base,32);
+}
+
+vuint8mf8_t
+test___riscv_vle8_v_u8mf8_tum(vbool64_t mask,vuint8mf8_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf8_tum(mask,merge,base,32);
+}
+
+vuint8mf4_t
+test___riscv_vle8_v_u8mf4_tum(vbool32_t mask,vuint8mf4_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf4_tum(mask,merge,base,32);
+}
+
+vuint8mf2_t
+test___riscv_vle8_v_u8mf2_tum(vbool16_t mask,vuint8mf2_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf2_tum(mask,merge,base,32);
+}
+
+vuint8m1_t
+test___riscv_vle8_v_u8m1_tum(vbool8_t mask,vuint8m1_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m1_tum(mask,merge,base,32);
+}
+
+vuint8m2_t
+test___riscv_vle8_v_u8m2_tum(vbool4_t mask,vuint8m2_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m2_tum(mask,merge,base,32);
+}
+
+vuint8m4_t
+test___riscv_vle8_v_u8m4_tum(vbool2_t mask,vuint8m4_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m4_tum(mask,merge,base,32);
+}
+
+vuint8m8_t
+test___riscv_vle8_v_u8m8_tum(vbool1_t mask,vuint8m8_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m8_tum(mask,merge,base,32);
+}
+
+vint16mf4_t
+test___riscv_vle16_v_i16mf4_tum(vbool64_t mask,vint16mf4_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf4_tum(mask,merge,base,32);
+}
+
+vint16mf2_t
+test___riscv_vle16_v_i16mf2_tum(vbool32_t mask,vint16mf2_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf2_tum(mask,merge,base,32);
+}
+
+vint16m1_t
+test___riscv_vle16_v_i16m1_tum(vbool16_t mask,vint16m1_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m1_tum(mask,merge,base,32);
+}
+
+vint16m2_t
+test___riscv_vle16_v_i16m2_tum(vbool8_t mask,vint16m2_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m2_tum(mask,merge,base,32);
+}
+
+vint16m4_t
+test___riscv_vle16_v_i16m4_tum(vbool4_t mask,vint16m4_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m4_tum(mask,merge,base,32);
+}
+
+vint16m8_t
+test___riscv_vle16_v_i16m8_tum(vbool2_t mask,vint16m8_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m8_tum(mask,merge,base,32);
+}
+
+vuint16mf4_t
+test___riscv_vle16_v_u16mf4_tum(vbool64_t mask,vuint16mf4_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf4_tum(mask,merge,base,32);
+}
+
+vuint16mf2_t
+test___riscv_vle16_v_u16mf2_tum(vbool32_t mask,vuint16mf2_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf2_tum(mask,merge,base,32);
+}
+
+vuint16m1_t
+test___riscv_vle16_v_u16m1_tum(vbool16_t mask,vuint16m1_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m1_tum(mask,merge,base,32);
+}
+
+vuint16m2_t
+test___riscv_vle16_v_u16m2_tum(vbool8_t mask,vuint16m2_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m2_tum(mask,merge,base,32);
+}
+
+vuint16m4_t
+test___riscv_vle16_v_u16m4_tum(vbool4_t mask,vuint16m4_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m4_tum(mask,merge,base,32);
+}
+
+vuint16m8_t
+test___riscv_vle16_v_u16m8_tum(vbool2_t mask,vuint16m8_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m8_tum(mask,merge,base,32);
+}
+
+vint32mf2_t
+test___riscv_vle32_v_i32mf2_tum(vbool64_t mask,vint32mf2_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32mf2_tum(mask,merge,base,32);
+}
+
+vint32m1_t
+test___riscv_vle32_v_i32m1_tum(vbool32_t mask,vint32m1_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m1_tum(mask,merge,base,32);
+}
+
+vint32m2_t
+test___riscv_vle32_v_i32m2_tum(vbool16_t mask,vint32m2_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m2_tum(mask,merge,base,32);
+}
+
+vint32m4_t
+test___riscv_vle32_v_i32m4_tum(vbool8_t mask,vint32m4_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m4_tum(mask,merge,base,32);
+}
+
+vint32m8_t
+test___riscv_vle32_v_i32m8_tum(vbool4_t mask,vint32m8_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m8_tum(mask,merge,base,32);
+}
+
+vuint32mf2_t
+test___riscv_vle32_v_u32mf2_tum(vbool64_t mask,vuint32mf2_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32mf2_tum(mask,merge,base,32);
+}
+
+vuint32m1_t
+test___riscv_vle32_v_u32m1_tum(vbool32_t mask,vuint32m1_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m1_tum(mask,merge,base,32);
+}
+
+vuint32m2_t
+test___riscv_vle32_v_u32m2_tum(vbool16_t mask,vuint32m2_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m2_tum(mask,merge,base,32);
+}
+
+vuint32m4_t
+test___riscv_vle32_v_u32m4_tum(vbool8_t mask,vuint32m4_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m4_tum(mask,merge,base,32);
+}
+
+vuint32m8_t
+test___riscv_vle32_v_u32m8_tum(vbool4_t mask,vuint32m8_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m8_tum(mask,merge,base,32);
+}
+
+vfloat32mf2_t
+test___riscv_vle32_v_f32mf2_tum(vbool64_t mask,vfloat32mf2_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32mf2_tum(mask,merge,base,32);
+}
+
+vfloat32m1_t
+test___riscv_vle32_v_f32m1_tum(vbool32_t mask,vfloat32m1_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m1_tum(mask,merge,base,32);
+}
+
+vfloat32m2_t
+test___riscv_vle32_v_f32m2_tum(vbool16_t mask,vfloat32m2_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m2_tum(mask,merge,base,32);
+}
+
+vfloat32m4_t
+test___riscv_vle32_v_f32m4_tum(vbool8_t mask,vfloat32m4_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m4_tum(mask,merge,base,32);
+}
+
+vfloat32m8_t
+test___riscv_vle32_v_f32m8_tum(vbool4_t mask,vfloat32m8_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m8_tum(mask,merge,base,32);
+}
+
+vint64m1_t
+test___riscv_vle64_v_i64m1_tum(vbool64_t mask,vint64m1_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m1_tum(mask,merge,base,32);
+}
+
+vint64m2_t
+test___riscv_vle64_v_i64m2_tum(vbool32_t mask,vint64m2_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m2_tum(mask,merge,base,32);
+}
+
+vint64m4_t
+test___riscv_vle64_v_i64m4_tum(vbool16_t mask,vint64m4_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m4_tum(mask,merge,base,32);
+}
+
+vint64m8_t
+test___riscv_vle64_v_i64m8_tum(vbool8_t mask,vint64m8_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m8_tum(mask,merge,base,32);
+}
+
+vuint64m1_t
+test___riscv_vle64_v_u64m1_tum(vbool64_t mask,vuint64m1_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m1_tum(mask,merge,base,32);
+}
+
+vuint64m2_t
+test___riscv_vle64_v_u64m2_tum(vbool32_t mask,vuint64m2_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m2_tum(mask,merge,base,32);
+}
+
+vuint64m4_t
+test___riscv_vle64_v_u64m4_tum(vbool16_t mask,vuint64m4_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m4_tum(mask,merge,base,32);
+}
+
+vuint64m8_t
+test___riscv_vle64_v_u64m8_tum(vbool8_t mask,vuint64m8_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m8_tum(mask,merge,base,32);
+}
+
+vfloat64m1_t
+test___riscv_vle64_v_f64m1_tum(vbool64_t mask,vfloat64m1_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m1_tum(mask,merge,base,32);
+}
+
+vfloat64m2_t
+test___riscv_vle64_v_f64m2_tum(vbool32_t mask,vfloat64m2_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m2_tum(mask,merge,base,32);
+}
+
+vfloat64m4_t
+test___riscv_vle64_v_f64m4_tum(vbool16_t mask,vfloat64m4_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m4_tum(mask,merge,base,32);
+}
+
+vfloat64m8_t
+test___riscv_vle64_v_f64m8_tum(vbool8_t mask,vfloat64m8_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m8_tum(mask,merge,base,32);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vle_tumu-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vle_tumu-1.c
new file mode 100644
index 0000000..b21e18f
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vle_tumu-1.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vle8_v_i8mf8_tumu(vbool64_t mask,vint8mf8_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf8_tumu(mask,merge,base,vl);
+}
+
+vint8mf4_t
+test___riscv_vle8_v_i8mf4_tumu(vbool32_t mask,vint8mf4_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf4_tumu(mask,merge,base,vl);
+}
+
+vint8mf2_t
+test___riscv_vle8_v_i8mf2_tumu(vbool16_t mask,vint8mf2_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf2_tumu(mask,merge,base,vl);
+}
+
+vint8m1_t
+test___riscv_vle8_v_i8m1_tumu(vbool8_t mask,vint8m1_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m1_tumu(mask,merge,base,vl);
+}
+
+vint8m2_t
+test___riscv_vle8_v_i8m2_tumu(vbool4_t mask,vint8m2_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m2_tumu(mask,merge,base,vl);
+}
+
+vint8m4_t
+test___riscv_vle8_v_i8m4_tumu(vbool2_t mask,vint8m4_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m4_tumu(mask,merge,base,vl);
+}
+
+vint8m8_t
+test___riscv_vle8_v_i8m8_tumu(vbool1_t mask,vint8m8_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m8_tumu(mask,merge,base,vl);
+}
+
+vuint8mf8_t
+test___riscv_vle8_v_u8mf8_tumu(vbool64_t mask,vuint8mf8_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf8_tumu(mask,merge,base,vl);
+}
+
+vuint8mf4_t
+test___riscv_vle8_v_u8mf4_tumu(vbool32_t mask,vuint8mf4_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf4_tumu(mask,merge,base,vl);
+}
+
+vuint8mf2_t
+test___riscv_vle8_v_u8mf2_tumu(vbool16_t mask,vuint8mf2_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf2_tumu(mask,merge,base,vl);
+}
+
+vuint8m1_t
+test___riscv_vle8_v_u8m1_tumu(vbool8_t mask,vuint8m1_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m1_tumu(mask,merge,base,vl);
+}
+
+vuint8m2_t
+test___riscv_vle8_v_u8m2_tumu(vbool4_t mask,vuint8m2_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m2_tumu(mask,merge,base,vl);
+}
+
+vuint8m4_t
+test___riscv_vle8_v_u8m4_tumu(vbool2_t mask,vuint8m4_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m4_tumu(mask,merge,base,vl);
+}
+
+vuint8m8_t
+test___riscv_vle8_v_u8m8_tumu(vbool1_t mask,vuint8m8_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m8_tumu(mask,merge,base,vl);
+}
+
+vint16mf4_t
+test___riscv_vle16_v_i16mf4_tumu(vbool64_t mask,vint16mf4_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf4_tumu(mask,merge,base,vl);
+}
+
+vint16mf2_t
+test___riscv_vle16_v_i16mf2_tumu(vbool32_t mask,vint16mf2_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf2_tumu(mask,merge,base,vl);
+}
+
+vint16m1_t
+test___riscv_vle16_v_i16m1_tumu(vbool16_t mask,vint16m1_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m1_tumu(mask,merge,base,vl);
+}
+
+vint16m2_t
+test___riscv_vle16_v_i16m2_tumu(vbool8_t mask,vint16m2_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m2_tumu(mask,merge,base,vl);
+}
+
+vint16m4_t
+test___riscv_vle16_v_i16m4_tumu(vbool4_t mask,vint16m4_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m4_tumu(mask,merge,base,vl);
+}
+
+vint16m8_t
+test___riscv_vle16_v_i16m8_tumu(vbool2_t mask,vint16m8_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m8_tumu(mask,merge,base,vl);
+}
+
+vuint16mf4_t
+test___riscv_vle16_v_u16mf4_tumu(vbool64_t mask,vuint16mf4_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf4_tumu(mask,merge,base,vl);
+}
+
+vuint16mf2_t
+test___riscv_vle16_v_u16mf2_tumu(vbool32_t mask,vuint16mf2_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf2_tumu(mask,merge,base,vl);
+}
+
+vuint16m1_t
+test___riscv_vle16_v_u16m1_tumu(vbool16_t mask,vuint16m1_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m1_tumu(mask,merge,base,vl);
+}
+
+vuint16m2_t
+test___riscv_vle16_v_u16m2_tumu(vbool8_t mask,vuint16m2_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m2_tumu(mask,merge,base,vl);
+}
+
+vuint16m4_t
+test___riscv_vle16_v_u16m4_tumu(vbool4_t mask,vuint16m4_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m4_tumu(mask,merge,base,vl);
+}
+
+vuint16m8_t
+test___riscv_vle16_v_u16m8_tumu(vbool2_t mask,vuint16m8_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m8_tumu(mask,merge,base,vl);
+}
+
+vint32mf2_t
+test___riscv_vle32_v_i32mf2_tumu(vbool64_t mask,vint32mf2_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32mf2_tumu(mask,merge,base,vl);
+}
+
+vint32m1_t
+test___riscv_vle32_v_i32m1_tumu(vbool32_t mask,vint32m1_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m1_tumu(mask,merge,base,vl);
+}
+
+vint32m2_t
+test___riscv_vle32_v_i32m2_tumu(vbool16_t mask,vint32m2_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m2_tumu(mask,merge,base,vl);
+}
+
+vint32m4_t
+test___riscv_vle32_v_i32m4_tumu(vbool8_t mask,vint32m4_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m4_tumu(mask,merge,base,vl);
+}
+
+vint32m8_t
+test___riscv_vle32_v_i32m8_tumu(vbool4_t mask,vint32m8_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m8_tumu(mask,merge,base,vl);
+}
+
+vuint32mf2_t
+test___riscv_vle32_v_u32mf2_tumu(vbool64_t mask,vuint32mf2_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32mf2_tumu(mask,merge,base,vl);
+}
+
+vuint32m1_t
+test___riscv_vle32_v_u32m1_tumu(vbool32_t mask,vuint32m1_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m1_tumu(mask,merge,base,vl);
+}
+
+vuint32m2_t
+test___riscv_vle32_v_u32m2_tumu(vbool16_t mask,vuint32m2_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m2_tumu(mask,merge,base,vl);
+}
+
+vuint32m4_t
+test___riscv_vle32_v_u32m4_tumu(vbool8_t mask,vuint32m4_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m4_tumu(mask,merge,base,vl);
+}
+
+vuint32m8_t
+test___riscv_vle32_v_u32m8_tumu(vbool4_t mask,vuint32m8_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m8_tumu(mask,merge,base,vl);
+}
+
+vfloat32mf2_t
+test___riscv_vle32_v_f32mf2_tumu(vbool64_t mask,vfloat32mf2_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32mf2_tumu(mask,merge,base,vl);
+}
+
+vfloat32m1_t
+test___riscv_vle32_v_f32m1_tumu(vbool32_t mask,vfloat32m1_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m1_tumu(mask,merge,base,vl);
+}
+
+vfloat32m2_t
+test___riscv_vle32_v_f32m2_tumu(vbool16_t mask,vfloat32m2_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m2_tumu(mask,merge,base,vl);
+}
+
+vfloat32m4_t
+test___riscv_vle32_v_f32m4_tumu(vbool8_t mask,vfloat32m4_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m4_tumu(mask,merge,base,vl);
+}
+
+vfloat32m8_t
+test___riscv_vle32_v_f32m8_tumu(vbool4_t mask,vfloat32m8_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m8_tumu(mask,merge,base,vl);
+}
+
+vint64m1_t
+test___riscv_vle64_v_i64m1_tumu(vbool64_t mask,vint64m1_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m1_tumu(mask,merge,base,vl);
+}
+
+vint64m2_t
+test___riscv_vle64_v_i64m2_tumu(vbool32_t mask,vint64m2_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m2_tumu(mask,merge,base,vl);
+}
+
+vint64m4_t
+test___riscv_vle64_v_i64m4_tumu(vbool16_t mask,vint64m4_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m4_tumu(mask,merge,base,vl);
+}
+
+vint64m8_t
+test___riscv_vle64_v_i64m8_tumu(vbool8_t mask,vint64m8_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m8_tumu(mask,merge,base,vl);
+}
+
+vuint64m1_t
+test___riscv_vle64_v_u64m1_tumu(vbool64_t mask,vuint64m1_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m1_tumu(mask,merge,base,vl);
+}
+
+vuint64m2_t
+test___riscv_vle64_v_u64m2_tumu(vbool32_t mask,vuint64m2_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m2_tumu(mask,merge,base,vl);
+}
+
+vuint64m4_t
+test___riscv_vle64_v_u64m4_tumu(vbool16_t mask,vuint64m4_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m4_tumu(mask,merge,base,vl);
+}
+
+vuint64m8_t
+test___riscv_vle64_v_u64m8_tumu(vbool8_t mask,vuint64m8_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m8_tumu(mask,merge,base,vl);
+}
+
+vfloat64m1_t
+test___riscv_vle64_v_f64m1_tumu(vbool64_t mask,vfloat64m1_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m1_tumu(mask,merge,base,vl);
+}
+
+vfloat64m2_t
+test___riscv_vle64_v_f64m2_tumu(vbool32_t mask,vfloat64m2_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m2_tumu(mask,merge,base,vl);
+}
+
+vfloat64m4_t
+test___riscv_vle64_v_f64m4_tumu(vbool16_t mask,vfloat64m4_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m4_tumu(mask,merge,base,vl);
+}
+
+vfloat64m8_t
+test___riscv_vle64_v_f64m8_tumu(vbool8_t mask,vfloat64m8_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m8_tumu(mask,merge,base,vl);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*mu\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vle_tumu-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vle_tumu-2.c
new file mode 100644
index 0000000..d2df6c4
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vle_tumu-2.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vle8_v_i8mf8_tumu(vbool64_t mask,vint8mf8_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf8_tumu(mask,merge,base,31);
+}
+
+vint8mf4_t
+test___riscv_vle8_v_i8mf4_tumu(vbool32_t mask,vint8mf4_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf4_tumu(mask,merge,base,31);
+}
+
+vint8mf2_t
+test___riscv_vle8_v_i8mf2_tumu(vbool16_t mask,vint8mf2_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf2_tumu(mask,merge,base,31);
+}
+
+vint8m1_t
+test___riscv_vle8_v_i8m1_tumu(vbool8_t mask,vint8m1_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m1_tumu(mask,merge,base,31);
+}
+
+vint8m2_t
+test___riscv_vle8_v_i8m2_tumu(vbool4_t mask,vint8m2_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m2_tumu(mask,merge,base,31);
+}
+
+vint8m4_t
+test___riscv_vle8_v_i8m4_tumu(vbool2_t mask,vint8m4_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m4_tumu(mask,merge,base,31);
+}
+
+vint8m8_t
+test___riscv_vle8_v_i8m8_tumu(vbool1_t mask,vint8m8_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m8_tumu(mask,merge,base,31);
+}
+
+vuint8mf8_t
+test___riscv_vle8_v_u8mf8_tumu(vbool64_t mask,vuint8mf8_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf8_tumu(mask,merge,base,31);
+}
+
+vuint8mf4_t
+test___riscv_vle8_v_u8mf4_tumu(vbool32_t mask,vuint8mf4_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf4_tumu(mask,merge,base,31);
+}
+
+vuint8mf2_t
+test___riscv_vle8_v_u8mf2_tumu(vbool16_t mask,vuint8mf2_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf2_tumu(mask,merge,base,31);
+}
+
+vuint8m1_t
+test___riscv_vle8_v_u8m1_tumu(vbool8_t mask,vuint8m1_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m1_tumu(mask,merge,base,31);
+}
+
+vuint8m2_t
+test___riscv_vle8_v_u8m2_tumu(vbool4_t mask,vuint8m2_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m2_tumu(mask,merge,base,31);
+}
+
+vuint8m4_t
+test___riscv_vle8_v_u8m4_tumu(vbool2_t mask,vuint8m4_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m4_tumu(mask,merge,base,31);
+}
+
+vuint8m8_t
+test___riscv_vle8_v_u8m8_tumu(vbool1_t mask,vuint8m8_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m8_tumu(mask,merge,base,31);
+}
+
+vint16mf4_t
+test___riscv_vle16_v_i16mf4_tumu(vbool64_t mask,vint16mf4_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf4_tumu(mask,merge,base,31);
+}
+
+vint16mf2_t
+test___riscv_vle16_v_i16mf2_tumu(vbool32_t mask,vint16mf2_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf2_tumu(mask,merge,base,31);
+}
+
+vint16m1_t
+test___riscv_vle16_v_i16m1_tumu(vbool16_t mask,vint16m1_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m1_tumu(mask,merge,base,31);
+}
+
+vint16m2_t
+test___riscv_vle16_v_i16m2_tumu(vbool8_t mask,vint16m2_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m2_tumu(mask,merge,base,31);
+}
+
+vint16m4_t
+test___riscv_vle16_v_i16m4_tumu(vbool4_t mask,vint16m4_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m4_tumu(mask,merge,base,31);
+}
+
+vint16m8_t
+test___riscv_vle16_v_i16m8_tumu(vbool2_t mask,vint16m8_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m8_tumu(mask,merge,base,31);
+}
+
+vuint16mf4_t
+test___riscv_vle16_v_u16mf4_tumu(vbool64_t mask,vuint16mf4_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf4_tumu(mask,merge,base,31);
+}
+
+vuint16mf2_t
+test___riscv_vle16_v_u16mf2_tumu(vbool32_t mask,vuint16mf2_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf2_tumu(mask,merge,base,31);
+}
+
+vuint16m1_t
+test___riscv_vle16_v_u16m1_tumu(vbool16_t mask,vuint16m1_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m1_tumu(mask,merge,base,31);
+}
+
+vuint16m2_t
+test___riscv_vle16_v_u16m2_tumu(vbool8_t mask,vuint16m2_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m2_tumu(mask,merge,base,31);
+}
+
+vuint16m4_t
+test___riscv_vle16_v_u16m4_tumu(vbool4_t mask,vuint16m4_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m4_tumu(mask,merge,base,31);
+}
+
+vuint16m8_t
+test___riscv_vle16_v_u16m8_tumu(vbool2_t mask,vuint16m8_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m8_tumu(mask,merge,base,31);
+}
+
+vint32mf2_t
+test___riscv_vle32_v_i32mf2_tumu(vbool64_t mask,vint32mf2_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32mf2_tumu(mask,merge,base,31);
+}
+
+vint32m1_t
+test___riscv_vle32_v_i32m1_tumu(vbool32_t mask,vint32m1_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m1_tumu(mask,merge,base,31);
+}
+
+vint32m2_t
+test___riscv_vle32_v_i32m2_tumu(vbool16_t mask,vint32m2_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m2_tumu(mask,merge,base,31);
+}
+
+vint32m4_t
+test___riscv_vle32_v_i32m4_tumu(vbool8_t mask,vint32m4_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m4_tumu(mask,merge,base,31);
+}
+
+vint32m8_t
+test___riscv_vle32_v_i32m8_tumu(vbool4_t mask,vint32m8_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m8_tumu(mask,merge,base,31);
+}
+
+vuint32mf2_t
+test___riscv_vle32_v_u32mf2_tumu(vbool64_t mask,vuint32mf2_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32mf2_tumu(mask,merge,base,31);
+}
+
+vuint32m1_t
+test___riscv_vle32_v_u32m1_tumu(vbool32_t mask,vuint32m1_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m1_tumu(mask,merge,base,31);
+}
+
+vuint32m2_t
+test___riscv_vle32_v_u32m2_tumu(vbool16_t mask,vuint32m2_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m2_tumu(mask,merge,base,31);
+}
+
+vuint32m4_t
+test___riscv_vle32_v_u32m4_tumu(vbool8_t mask,vuint32m4_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m4_tumu(mask,merge,base,31);
+}
+
+vuint32m8_t
+test___riscv_vle32_v_u32m8_tumu(vbool4_t mask,vuint32m8_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m8_tumu(mask,merge,base,31);
+}
+
+vfloat32mf2_t
+test___riscv_vle32_v_f32mf2_tumu(vbool64_t mask,vfloat32mf2_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32mf2_tumu(mask,merge,base,31);
+}
+
+vfloat32m1_t
+test___riscv_vle32_v_f32m1_tumu(vbool32_t mask,vfloat32m1_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m1_tumu(mask,merge,base,31);
+}
+
+vfloat32m2_t
+test___riscv_vle32_v_f32m2_tumu(vbool16_t mask,vfloat32m2_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m2_tumu(mask,merge,base,31);
+}
+
+vfloat32m4_t
+test___riscv_vle32_v_f32m4_tumu(vbool8_t mask,vfloat32m4_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m4_tumu(mask,merge,base,31);
+}
+
+vfloat32m8_t
+test___riscv_vle32_v_f32m8_tumu(vbool4_t mask,vfloat32m8_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m8_tumu(mask,merge,base,31);
+}
+
+vint64m1_t
+test___riscv_vle64_v_i64m1_tumu(vbool64_t mask,vint64m1_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m1_tumu(mask,merge,base,31);
+}
+
+vint64m2_t
+test___riscv_vle64_v_i64m2_tumu(vbool32_t mask,vint64m2_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m2_tumu(mask,merge,base,31);
+}
+
+vint64m4_t
+test___riscv_vle64_v_i64m4_tumu(vbool16_t mask,vint64m4_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m4_tumu(mask,merge,base,31);
+}
+
+vint64m8_t
+test___riscv_vle64_v_i64m8_tumu(vbool8_t mask,vint64m8_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m8_tumu(mask,merge,base,31);
+}
+
+vuint64m1_t
+test___riscv_vle64_v_u64m1_tumu(vbool64_t mask,vuint64m1_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m1_tumu(mask,merge,base,31);
+}
+
+vuint64m2_t
+test___riscv_vle64_v_u64m2_tumu(vbool32_t mask,vuint64m2_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m2_tumu(mask,merge,base,31);
+}
+
+vuint64m4_t
+test___riscv_vle64_v_u64m4_tumu(vbool16_t mask,vuint64m4_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m4_tumu(mask,merge,base,31);
+}
+
+vuint64m8_t
+test___riscv_vle64_v_u64m8_tumu(vbool8_t mask,vuint64m8_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m8_tumu(mask,merge,base,31);
+}
+
+vfloat64m1_t
+test___riscv_vle64_v_f64m1_tumu(vbool64_t mask,vfloat64m1_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m1_tumu(mask,merge,base,31);
+}
+
+vfloat64m2_t
+test___riscv_vle64_v_f64m2_tumu(vbool32_t mask,vfloat64m2_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m2_tumu(mask,merge,base,31);
+}
+
+vfloat64m4_t
+test___riscv_vle64_v_f64m4_tumu(vbool16_t mask,vfloat64m4_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m4_tumu(mask,merge,base,31);
+}
+
+vfloat64m8_t
+test___riscv_vle64_v_f64m8_tumu(vbool8_t mask,vfloat64m8_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m8_tumu(mask,merge,base,31);
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*tu,\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*tu,\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*tu,\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*mu\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*mu\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*mu\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*mu\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*mu\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*mu\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*mu\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*mu\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*mu\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vle_tumu-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vle_tumu-3.c
new file mode 100644
index 0000000..828a573
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vle_tumu-3.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vle8_v_i8mf8_tumu(vbool64_t mask,vint8mf8_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf8_tumu(mask,merge,base,32);
+}
+
+vint8mf4_t
+test___riscv_vle8_v_i8mf4_tumu(vbool32_t mask,vint8mf4_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf4_tumu(mask,merge,base,32);
+}
+
+vint8mf2_t
+test___riscv_vle8_v_i8mf2_tumu(vbool16_t mask,vint8mf2_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8mf2_tumu(mask,merge,base,32);
+}
+
+vint8m1_t
+test___riscv_vle8_v_i8m1_tumu(vbool8_t mask,vint8m1_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m1_tumu(mask,merge,base,32);
+}
+
+vint8m2_t
+test___riscv_vle8_v_i8m2_tumu(vbool4_t mask,vint8m2_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m2_tumu(mask,merge,base,32);
+}
+
+vint8m4_t
+test___riscv_vle8_v_i8m4_tumu(vbool2_t mask,vint8m4_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m4_tumu(mask,merge,base,32);
+}
+
+vint8m8_t
+test___riscv_vle8_v_i8m8_tumu(vbool1_t mask,vint8m8_t merge,int8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_i8m8_tumu(mask,merge,base,32);
+}
+
+vuint8mf8_t
+test___riscv_vle8_v_u8mf8_tumu(vbool64_t mask,vuint8mf8_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf8_tumu(mask,merge,base,32);
+}
+
+vuint8mf4_t
+test___riscv_vle8_v_u8mf4_tumu(vbool32_t mask,vuint8mf4_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf4_tumu(mask,merge,base,32);
+}
+
+vuint8mf2_t
+test___riscv_vle8_v_u8mf2_tumu(vbool16_t mask,vuint8mf2_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8mf2_tumu(mask,merge,base,32);
+}
+
+vuint8m1_t
+test___riscv_vle8_v_u8m1_tumu(vbool8_t mask,vuint8m1_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m1_tumu(mask,merge,base,32);
+}
+
+vuint8m2_t
+test___riscv_vle8_v_u8m2_tumu(vbool4_t mask,vuint8m2_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m2_tumu(mask,merge,base,32);
+}
+
+vuint8m4_t
+test___riscv_vle8_v_u8m4_tumu(vbool2_t mask,vuint8m4_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m4_tumu(mask,merge,base,32);
+}
+
+vuint8m8_t
+test___riscv_vle8_v_u8m8_tumu(vbool1_t mask,vuint8m8_t merge,uint8_t* base,size_t vl)
+{
+  return __riscv_vle8_v_u8m8_tumu(mask,merge,base,32);
+}
+
+vint16mf4_t
+test___riscv_vle16_v_i16mf4_tumu(vbool64_t mask,vint16mf4_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf4_tumu(mask,merge,base,32);
+}
+
+vint16mf2_t
+test___riscv_vle16_v_i16mf2_tumu(vbool32_t mask,vint16mf2_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16mf2_tumu(mask,merge,base,32);
+}
+
+vint16m1_t
+test___riscv_vle16_v_i16m1_tumu(vbool16_t mask,vint16m1_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m1_tumu(mask,merge,base,32);
+}
+
+vint16m2_t
+test___riscv_vle16_v_i16m2_tumu(vbool8_t mask,vint16m2_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m2_tumu(mask,merge,base,32);
+}
+
+vint16m4_t
+test___riscv_vle16_v_i16m4_tumu(vbool4_t mask,vint16m4_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m4_tumu(mask,merge,base,32);
+}
+
+vint16m8_t
+test___riscv_vle16_v_i16m8_tumu(vbool2_t mask,vint16m8_t merge,int16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_i16m8_tumu(mask,merge,base,32);
+}
+
+vuint16mf4_t
+test___riscv_vle16_v_u16mf4_tumu(vbool64_t mask,vuint16mf4_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf4_tumu(mask,merge,base,32);
+}
+
+vuint16mf2_t
+test___riscv_vle16_v_u16mf2_tumu(vbool32_t mask,vuint16mf2_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16mf2_tumu(mask,merge,base,32);
+}
+
+vuint16m1_t
+test___riscv_vle16_v_u16m1_tumu(vbool16_t mask,vuint16m1_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m1_tumu(mask,merge,base,32);
+}
+
+vuint16m2_t
+test___riscv_vle16_v_u16m2_tumu(vbool8_t mask,vuint16m2_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m2_tumu(mask,merge,base,32);
+}
+
+vuint16m4_t
+test___riscv_vle16_v_u16m4_tumu(vbool4_t mask,vuint16m4_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m4_tumu(mask,merge,base,32);
+}
+
+vuint16m8_t
+test___riscv_vle16_v_u16m8_tumu(vbool2_t mask,vuint16m8_t merge,uint16_t* base,size_t vl)
+{
+  return __riscv_vle16_v_u16m8_tumu(mask,merge,base,32);
+}
+
+vint32mf2_t
+test___riscv_vle32_v_i32mf2_tumu(vbool64_t mask,vint32mf2_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32mf2_tumu(mask,merge,base,32);
+}
+
+vint32m1_t
+test___riscv_vle32_v_i32m1_tumu(vbool32_t mask,vint32m1_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m1_tumu(mask,merge,base,32);
+}
+
+vint32m2_t
+test___riscv_vle32_v_i32m2_tumu(vbool16_t mask,vint32m2_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m2_tumu(mask,merge,base,32);
+}
+
+vint32m4_t
+test___riscv_vle32_v_i32m4_tumu(vbool8_t mask,vint32m4_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m4_tumu(mask,merge,base,32);
+}
+
+vint32m8_t
+test___riscv_vle32_v_i32m8_tumu(vbool4_t mask,vint32m8_t merge,int32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_i32m8_tumu(mask,merge,base,32);
+}
+
+vuint32mf2_t
+test___riscv_vle32_v_u32mf2_tumu(vbool64_t mask,vuint32mf2_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32mf2_tumu(mask,merge,base,32);
+}
+
+vuint32m1_t
+test___riscv_vle32_v_u32m1_tumu(vbool32_t mask,vuint32m1_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m1_tumu(mask,merge,base,32);
+}
+
+vuint32m2_t
+test___riscv_vle32_v_u32m2_tumu(vbool16_t mask,vuint32m2_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m2_tumu(mask,merge,base,32);
+}
+
+vuint32m4_t
+test___riscv_vle32_v_u32m4_tumu(vbool8_t mask,vuint32m4_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m4_tumu(mask,merge,base,32);
+}
+
+vuint32m8_t
+test___riscv_vle32_v_u32m8_tumu(vbool4_t mask,vuint32m8_t merge,uint32_t* base,size_t vl)
+{
+  return __riscv_vle32_v_u32m8_tumu(mask,merge,base,32);
+}
+
+vfloat32mf2_t
+test___riscv_vle32_v_f32mf2_tumu(vbool64_t mask,vfloat32mf2_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32mf2_tumu(mask,merge,base,32);
+}
+
+vfloat32m1_t
+test___riscv_vle32_v_f32m1_tumu(vbool32_t mask,vfloat32m1_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m1_tumu(mask,merge,base,32);
+}
+
+vfloat32m2_t
+test___riscv_vle32_v_f32m2_tumu(vbool16_t mask,vfloat32m2_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m2_tumu(mask,merge,base,32);
+}
+
+vfloat32m4_t
+test___riscv_vle32_v_f32m4_tumu(vbool8_t mask,vfloat32m4_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m4_tumu(mask,merge,base,32);
+}
+
+vfloat32m8_t
+test___riscv_vle32_v_f32m8_tumu(vbool4_t mask,vfloat32m8_t merge,float* base,size_t vl)
+{
+  return __riscv_vle32_v_f32m8_tumu(mask,merge,base,32);
+}
+
+vint64m1_t
+test___riscv_vle64_v_i64m1_tumu(vbool64_t mask,vint64m1_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m1_tumu(mask,merge,base,32);
+}
+
+vint64m2_t
+test___riscv_vle64_v_i64m2_tumu(vbool32_t mask,vint64m2_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m2_tumu(mask,merge,base,32);
+}
+
+vint64m4_t
+test___riscv_vle64_v_i64m4_tumu(vbool16_t mask,vint64m4_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m4_tumu(mask,merge,base,32);
+}
+
+vint64m8_t
+test___riscv_vle64_v_i64m8_tumu(vbool8_t mask,vint64m8_t merge,int64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_i64m8_tumu(mask,merge,base,32);
+}
+
+vuint64m1_t
+test___riscv_vle64_v_u64m1_tumu(vbool64_t mask,vuint64m1_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m1_tumu(mask,merge,base,32);
+}
+
+vuint64m2_t
+test___riscv_vle64_v_u64m2_tumu(vbool32_t mask,vuint64m2_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m2_tumu(mask,merge,base,32);
+}
+
+vuint64m4_t
+test___riscv_vle64_v_u64m4_tumu(vbool16_t mask,vuint64m4_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m4_tumu(mask,merge,base,32);
+}
+
+vuint64m8_t
+test___riscv_vle64_v_u64m8_tumu(vbool8_t mask,vuint64m8_t merge,uint64_t* base,size_t vl)
+{
+  return __riscv_vle64_v_u64m8_tumu(mask,merge,base,32);
+}
+
+vfloat64m1_t
+test___riscv_vle64_v_f64m1_tumu(vbool64_t mask,vfloat64m1_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m1_tumu(mask,merge,base,32);
+}
+
+vfloat64m2_t
+test___riscv_vle64_v_f64m2_tumu(vbool32_t mask,vfloat64m2_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m2_tumu(mask,merge,base,32);
+}
+
+vfloat64m4_t
+test___riscv_vle64_v_f64m4_tumu(vbool16_t mask,vfloat64m4_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m4_tumu(mask,merge,base,32);
+}
+
+vfloat64m8_t
+test___riscv_vle64_v_f64m8_tumu(vbool8_t mask,vfloat64m8_t merge,double* base,size_t vl)
+{
+  return __riscv_vle64_v_f64m8_tumu(mask,merge,base,32);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*mu\s+vle8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*mu\s+vle16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*mu\s+vle32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vle64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vlm_vsm-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vlm_vsm-1.c
new file mode 100644
index 0000000..f2f4cc9
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vlm_vsm-1.c
@@ -0,0 +1,75 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vbool1_t test___riscv_vlm_v_b1_vl(const uint8_t *base, size_t vl) {
+  return __riscv_vlm_v_b1(base, vl);
+}
+
+void test___riscv_vsm_v_b1_vl(uint8_t *base, vbool1_t value, size_t vl) {
+  __riscv_vsm_v_b1(base, value, vl);
+}
+
+vbool2_t test___riscv_vlm_v_b2_vl(const uint8_t *base, size_t vl) {
+  return __riscv_vlm_v_b2(base, vl);
+}
+
+void test___riscv_vsm_v_b2_vl(uint8_t *base, vbool2_t value, size_t vl) {
+  __riscv_vsm_v_b2(base, value, vl);
+}
+
+vbool4_t test___riscv_vlm_v_b4_vl(const uint8_t *base, size_t vl) {
+  return __riscv_vlm_v_b4(base, vl);
+}
+
+void test___riscv_vsm_v_b4_vl(uint8_t *base, vbool4_t value, size_t vl) {
+  __riscv_vsm_v_b4(base, value, vl);
+}
+
+vbool8_t test___riscv_vlm_v_b8_vl(const uint8_t *base, size_t vl) {
+  return __riscv_vlm_v_b8(base, vl);
+}
+
+void test___riscv_vsm_v_b8_vl(uint8_t *base, vbool8_t value, size_t vl) {
+  __riscv_vsm_v_b8(base, value, vl);
+}
+
+vbool16_t test___riscv_vlm_v_b16_vl(const uint8_t *base, size_t vl) {
+  return __riscv_vlm_v_b16(base, vl);
+}
+
+void test___riscv_vsm_v_b16_vl(uint8_t *base, vbool16_t value, size_t vl) {
+  __riscv_vsm_v_b16(base, value, vl);
+}
+
+vbool32_t test___riscv_vlm_v_b32_vl(const uint8_t *base, size_t vl) {
+  return __riscv_vlm_v_b32(base, vl);
+}
+
+void test___riscv_vsm_v_b32_vl(uint8_t *base, vbool32_t value, size_t vl) {
+  __riscv_vsm_v_b32(base, value, vl);
+}
+
+vbool64_t test___riscv_vlm_v_b64_vl(const uint8_t *base, size_t vl) {
+  return __riscv_vlm_v_b64(base, vl);
+}
+
+void test___riscv_vsm_v_b64_vl(uint8_t *base, vbool64_t value, size_t vl) {
+  __riscv_vsm_v_b64(base, value, vl);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vlm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vlm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vlm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vlm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vlm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vlm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vlm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vlm_vsm-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vlm_vsm-2.c
new file mode 100644
index 0000000..66e687f
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vlm_vsm-2.c
@@ -0,0 +1,75 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vbool1_t test___riscv_vlm_v_b1_vl(const uint8_t *base, size_t vl) {
+  return __riscv_vlm_v_b1(base, 31);
+}
+
+void test___riscv_vsm_v_b1_vl(uint8_t *base, vbool1_t value, size_t vl) {
+  __riscv_vsm_v_b1(base, value, 31);
+}
+
+vbool2_t test___riscv_vlm_v_b2_vl(const uint8_t *base, size_t vl) {
+  return __riscv_vlm_v_b2(base, 31);
+}
+
+void test___riscv_vsm_v_b2_vl(uint8_t *base, vbool2_t value, size_t vl) {
+  __riscv_vsm_v_b2(base, value, 31);
+}
+
+vbool4_t test___riscv_vlm_v_b4_vl(const uint8_t *base, size_t vl) {
+  return __riscv_vlm_v_b4(base, 31);
+}
+
+void test___riscv_vsm_v_b4_vl(uint8_t *base, vbool4_t value, size_t vl) {
+  __riscv_vsm_v_b4(base, value, 31);
+}
+
+vbool8_t test___riscv_vlm_v_b8_vl(const uint8_t *base, size_t vl) {
+  return __riscv_vlm_v_b8(base, 31);
+}
+
+void test___riscv_vsm_v_b8_vl(uint8_t *base, vbool8_t value, size_t vl) {
+  __riscv_vsm_v_b8(base, value, 31);
+}
+
+vbool16_t test___riscv_vlm_v_b16_vl(const uint8_t *base, size_t vl) {
+  return __riscv_vlm_v_b16(base, 31);
+}
+
+void test___riscv_vsm_v_b16_vl(uint8_t *base, vbool16_t value, size_t vl) {
+  __riscv_vsm_v_b16(base, value, 31);
+}
+
+vbool32_t test___riscv_vlm_v_b32_vl(const uint8_t *base, size_t vl) {
+  return __riscv_vlm_v_b32(base, 31);
+}
+
+void test___riscv_vsm_v_b32_vl(uint8_t *base, vbool32_t value, size_t vl) {
+  __riscv_vsm_v_b32(base, value, 31);
+}
+
+vbool64_t test___riscv_vlm_v_b64_vl(const uint8_t *base, size_t vl) {
+  return __riscv_vlm_v_b64(base, 31);
+}
+
+void test___riscv_vsm_v_b64_vl(uint8_t *base, vbool64_t value, size_t vl) {
+  __riscv_vsm_v_b64(base, value, 31);
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vlm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vlm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vlm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vlm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vlm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vlm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vlm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vlm_vsm-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vlm_vsm-3.c
new file mode 100644
index 0000000..58ca73c
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vlm_vsm-3.c
@@ -0,0 +1,75 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vbool1_t test___riscv_vlm_v_b1_vl(const uint8_t *base, size_t vl) {
+  return __riscv_vlm_v_b1(base, 32);
+}
+
+void test___riscv_vsm_v_b1_vl(uint8_t *base, vbool1_t value, size_t vl) {
+  __riscv_vsm_v_b1(base, value, 32);
+}
+
+vbool2_t test___riscv_vlm_v_b2_vl(const uint8_t *base, size_t vl) {
+  return __riscv_vlm_v_b2(base, 32);
+}
+
+void test___riscv_vsm_v_b2_vl(uint8_t *base, vbool2_t value, size_t vl) {
+  __riscv_vsm_v_b2(base, value, 32);
+}
+
+vbool4_t test___riscv_vlm_v_b4_vl(const uint8_t *base, size_t vl) {
+  return __riscv_vlm_v_b4(base, 32);
+}
+
+void test___riscv_vsm_v_b4_vl(uint8_t *base, vbool4_t value, size_t vl) {
+  __riscv_vsm_v_b4(base, value, 32);
+}
+
+vbool8_t test___riscv_vlm_v_b8_vl(const uint8_t *base, size_t vl) {
+  return __riscv_vlm_v_b8(base, 32);
+}
+
+void test___riscv_vsm_v_b8_vl(uint8_t *base, vbool8_t value, size_t vl) {
+  __riscv_vsm_v_b8(base, value, 32);
+}
+
+vbool16_t test___riscv_vlm_v_b16_vl(const uint8_t *base, size_t vl) {
+  return __riscv_vlm_v_b16(base, 32);
+}
+
+void test___riscv_vsm_v_b16_vl(uint8_t *base, vbool16_t value, size_t vl) {
+  __riscv_vsm_v_b16(base, value, 32);
+}
+
+vbool32_t test___riscv_vlm_v_b32_vl(const uint8_t *base, size_t vl) {
+  return __riscv_vlm_v_b32(base, 32);
+}
+
+void test___riscv_vsm_v_b32_vl(uint8_t *base, vbool32_t value, size_t vl) {
+  __riscv_vsm_v_b32(base, value, 32);
+}
+
+vbool64_t test___riscv_vlm_v_b64_vl(const uint8_t *base, size_t vl) {
+  return __riscv_vlm_v_b64(base, 32);
+}
+
+void test___riscv_vsm_v_b64_vl(uint8_t *base, vbool64_t value, size_t vl) {
+  __riscv_vsm_v_b64(base, value, 32);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vlm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vlm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vlm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vlm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vlm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vlm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vlm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 1 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v-1.c
new file mode 100644
index 0000000..d68558a
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v-1.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei16_v_i8mf8(const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf8(base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei16_v_i8mf4(const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf4(base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei16_v_i8mf2(const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf2(base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei16_v_i8m1(const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m1(base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei16_v_i8m2(const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m2(base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vloxei16_v_i8m4(const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m4(base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei16_v_i16mf4(const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf4(base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei16_v_i16mf2(const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf2(base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei16_v_i16m1(const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m1(base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei16_v_i16m2(const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m2(base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei16_v_i16m4(const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m4(base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vloxei16_v_i16m8(const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m8(base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei16_v_i32mf2(const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32mf2(base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei16_v_i32m1(const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m1(base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei16_v_i32m2(const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m2(base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei16_v_i32m4(const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m4(base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei16_v_i32m8(const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m8(base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei16_v_i64m1(const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m1(base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei16_v_i64m2(const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m2(base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei16_v_i64m4(const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m4(base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei16_v_i64m8(const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m8(base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16_v_u8mf8(const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf8(base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16_v_u8mf4(const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf4(base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16_v_u8mf2(const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf2(base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei16_v_u8m1(const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m1(base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei16_v_u8m2(const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m2(base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vloxei16_v_u8m4(const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m4(base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16_v_u16mf4(const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf4(base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16_v_u16mf2(const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf2(base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei16_v_u16m1(const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m1(base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei16_v_u16m2(const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m2(base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei16_v_u16m4(const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m4(base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vloxei16_v_u16m8(const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m8(base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16_v_u32mf2(const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32mf2(base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei16_v_u32m1(const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m1(base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei16_v_u32m2(const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m2(base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei16_v_u32m4(const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m4(base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei16_v_u32m8(const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m8(base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei16_v_u64m1(const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m1(base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei16_v_u64m2(const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m2(base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei16_v_u64m4(const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m4(base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei16_v_u64m8(const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m8(base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16_v_f32mf2(const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32mf2(base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16_v_f32m1(const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m1(base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16_v_f32m2(const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m2(base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16_v_f32m4(const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m4(base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16_v_f32m8(const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m8(base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16_v_f64m1(const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m1(base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16_v_f64m2(const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m2(base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16_v_f64m4(const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m4(base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16_v_f64m8(const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m8(base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v-2.c
new file mode 100644
index 0000000..284e6d7
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v-2.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei16_v_i8mf8(const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf8(base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei16_v_i8mf4(const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf4(base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei16_v_i8mf2(const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf2(base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei16_v_i8m1(const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m1(base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei16_v_i8m2(const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m2(base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vloxei16_v_i8m4(const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m4(base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei16_v_i16mf4(const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf4(base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei16_v_i16mf2(const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf2(base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei16_v_i16m1(const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m1(base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei16_v_i16m2(const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m2(base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei16_v_i16m4(const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m4(base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vloxei16_v_i16m8(const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m8(base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei16_v_i32mf2(const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32mf2(base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei16_v_i32m1(const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m1(base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei16_v_i32m2(const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m2(base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei16_v_i32m4(const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m4(base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei16_v_i32m8(const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m8(base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei16_v_i64m1(const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m1(base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei16_v_i64m2(const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m2(base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei16_v_i64m4(const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m4(base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei16_v_i64m8(const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m8(base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16_v_u8mf8(const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf8(base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16_v_u8mf4(const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf4(base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16_v_u8mf2(const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf2(base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei16_v_u8m1(const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m1(base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei16_v_u8m2(const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m2(base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vloxei16_v_u8m4(const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m4(base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16_v_u16mf4(const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf4(base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16_v_u16mf2(const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf2(base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei16_v_u16m1(const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m1(base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei16_v_u16m2(const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m2(base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei16_v_u16m4(const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m4(base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vloxei16_v_u16m8(const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m8(base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16_v_u32mf2(const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32mf2(base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei16_v_u32m1(const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m1(base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei16_v_u32m2(const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m2(base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei16_v_u32m4(const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m4(base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei16_v_u32m8(const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m8(base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei16_v_u64m1(const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m1(base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei16_v_u64m2(const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m2(base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei16_v_u64m4(const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m4(base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei16_v_u64m8(const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m8(base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16_v_f32mf2(const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32mf2(base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16_v_f32m1(const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m1(base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16_v_f32m2(const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m2(base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16_v_f32m4(const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m4(base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16_v_f32m8(const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m8(base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16_v_f64m1(const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m1(base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16_v_f64m2(const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m2(base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16_v_f64m4(const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m4(base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16_v_f64m8(const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m8(base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v-3.c
new file mode 100644
index 0000000..a716994
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v-3.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei16_v_i8mf8(const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf8(base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei16_v_i8mf4(const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf4(base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei16_v_i8mf2(const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf2(base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei16_v_i8m1(const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m1(base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei16_v_i8m2(const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m2(base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vloxei16_v_i8m4(const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m4(base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei16_v_i16mf4(const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf4(base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei16_v_i16mf2(const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf2(base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei16_v_i16m1(const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m1(base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei16_v_i16m2(const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m2(base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei16_v_i16m4(const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m4(base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vloxei16_v_i16m8(const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m8(base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei16_v_i32mf2(const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32mf2(base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei16_v_i32m1(const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m1(base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei16_v_i32m2(const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m2(base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei16_v_i32m4(const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m4(base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei16_v_i32m8(const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m8(base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei16_v_i64m1(const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m1(base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei16_v_i64m2(const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m2(base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei16_v_i64m4(const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m4(base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei16_v_i64m8(const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m8(base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16_v_u8mf8(const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf8(base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16_v_u8mf4(const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf4(base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16_v_u8mf2(const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf2(base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei16_v_u8m1(const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m1(base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei16_v_u8m2(const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m2(base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vloxei16_v_u8m4(const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m4(base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16_v_u16mf4(const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf4(base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16_v_u16mf2(const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf2(base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei16_v_u16m1(const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m1(base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei16_v_u16m2(const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m2(base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei16_v_u16m4(const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m4(base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vloxei16_v_u16m8(const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m8(base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16_v_u32mf2(const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32mf2(base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei16_v_u32m1(const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m1(base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei16_v_u32m2(const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m2(base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei16_v_u32m4(const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m4(base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei16_v_u32m8(const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m8(base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei16_v_u64m1(const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m1(base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei16_v_u64m2(const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m2(base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei16_v_u64m4(const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m4(base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei16_v_u64m8(const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m8(base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16_v_f32mf2(const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32mf2(base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16_v_f32m1(const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m1(base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16_v_f32m2(const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m2(base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16_v_f32m4(const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m4(base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16_v_f32m8(const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m8(base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16_v_f64m1(const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m1(base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16_v_f64m2(const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m2(base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16_v_f64m4(const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m4(base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16_v_f64m8(const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m8(base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_m-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_m-1.c
new file mode 100644
index 0000000..061c608
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_m-1.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei16_v_i8mf8_m(vbool64_t mask,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf8_m(mask,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei16_v_i8mf4_m(vbool32_t mask,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf4_m(mask,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei16_v_i8mf2_m(vbool16_t mask,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf2_m(mask,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei16_v_i8m1_m(vbool8_t mask,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m1_m(mask,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei16_v_i8m2_m(vbool4_t mask,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m2_m(mask,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vloxei16_v_i8m4_m(vbool2_t mask,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m4_m(mask,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei16_v_i16mf4_m(vbool64_t mask,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf4_m(mask,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei16_v_i16mf2_m(vbool32_t mask,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf2_m(mask,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei16_v_i16m1_m(vbool16_t mask,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m1_m(mask,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei16_v_i16m2_m(vbool8_t mask,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m2_m(mask,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei16_v_i16m4_m(vbool4_t mask,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m4_m(mask,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vloxei16_v_i16m8_m(vbool2_t mask,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m8_m(mask,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei16_v_i32mf2_m(vbool64_t mask,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32mf2_m(mask,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei16_v_i32m1_m(vbool32_t mask,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m1_m(mask,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei16_v_i32m2_m(vbool16_t mask,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m2_m(mask,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei16_v_i32m4_m(vbool8_t mask,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m4_m(mask,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei16_v_i32m8_m(vbool4_t mask,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m8_m(mask,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei16_v_i64m1_m(vbool64_t mask,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m1_m(mask,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei16_v_i64m2_m(vbool32_t mask,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m2_m(mask,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei16_v_i64m4_m(vbool16_t mask,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m4_m(mask,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei16_v_i64m8_m(vbool8_t mask,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m8_m(mask,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16_v_u8mf8_m(vbool64_t mask,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf8_m(mask,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16_v_u8mf4_m(vbool32_t mask,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf4_m(mask,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16_v_u8mf2_m(vbool16_t mask,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf2_m(mask,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei16_v_u8m1_m(vbool8_t mask,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m1_m(mask,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei16_v_u8m2_m(vbool4_t mask,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m2_m(mask,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vloxei16_v_u8m4_m(vbool2_t mask,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m4_m(mask,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16_v_u16mf4_m(vbool64_t mask,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf4_m(mask,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16_v_u16mf2_m(vbool32_t mask,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf2_m(mask,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei16_v_u16m1_m(vbool16_t mask,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m1_m(mask,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei16_v_u16m2_m(vbool8_t mask,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m2_m(mask,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei16_v_u16m4_m(vbool4_t mask,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m4_m(mask,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vloxei16_v_u16m8_m(vbool2_t mask,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m8_m(mask,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16_v_u32mf2_m(vbool64_t mask,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32mf2_m(mask,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei16_v_u32m1_m(vbool32_t mask,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m1_m(mask,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei16_v_u32m2_m(vbool16_t mask,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m2_m(mask,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei16_v_u32m4_m(vbool8_t mask,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m4_m(mask,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei16_v_u32m8_m(vbool4_t mask,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m8_m(mask,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei16_v_u64m1_m(vbool64_t mask,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m1_m(mask,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei16_v_u64m2_m(vbool32_t mask,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m2_m(mask,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei16_v_u64m4_m(vbool16_t mask,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m4_m(mask,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei16_v_u64m8_m(vbool8_t mask,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m8_m(mask,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16_v_f32mf2_m(vbool64_t mask,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32mf2_m(mask,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16_v_f32m1_m(vbool32_t mask,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m1_m(mask,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16_v_f32m2_m(vbool16_t mask,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m2_m(mask,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16_v_f32m4_m(vbool8_t mask,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m4_m(mask,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16_v_f32m8_m(vbool4_t mask,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m8_m(mask,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16_v_f64m1_m(vbool64_t mask,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m1_m(mask,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16_v_f64m2_m(vbool32_t mask,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m2_m(mask,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16_v_f64m4_m(vbool16_t mask,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m4_m(mask,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16_v_f64m8_m(vbool8_t mask,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m8_m(mask,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_m-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_m-2.c
new file mode 100644
index 0000000..2efc3f4
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_m-2.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei16_v_i8mf8_m(vbool64_t mask,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf8_m(mask,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei16_v_i8mf4_m(vbool32_t mask,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf4_m(mask,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei16_v_i8mf2_m(vbool16_t mask,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf2_m(mask,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei16_v_i8m1_m(vbool8_t mask,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m1_m(mask,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei16_v_i8m2_m(vbool4_t mask,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m2_m(mask,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vloxei16_v_i8m4_m(vbool2_t mask,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m4_m(mask,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei16_v_i16mf4_m(vbool64_t mask,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf4_m(mask,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei16_v_i16mf2_m(vbool32_t mask,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf2_m(mask,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei16_v_i16m1_m(vbool16_t mask,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m1_m(mask,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei16_v_i16m2_m(vbool8_t mask,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m2_m(mask,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei16_v_i16m4_m(vbool4_t mask,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m4_m(mask,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vloxei16_v_i16m8_m(vbool2_t mask,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m8_m(mask,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei16_v_i32mf2_m(vbool64_t mask,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32mf2_m(mask,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei16_v_i32m1_m(vbool32_t mask,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m1_m(mask,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei16_v_i32m2_m(vbool16_t mask,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m2_m(mask,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei16_v_i32m4_m(vbool8_t mask,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m4_m(mask,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei16_v_i32m8_m(vbool4_t mask,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m8_m(mask,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei16_v_i64m1_m(vbool64_t mask,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m1_m(mask,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei16_v_i64m2_m(vbool32_t mask,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m2_m(mask,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei16_v_i64m4_m(vbool16_t mask,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m4_m(mask,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei16_v_i64m8_m(vbool8_t mask,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m8_m(mask,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16_v_u8mf8_m(vbool64_t mask,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf8_m(mask,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16_v_u8mf4_m(vbool32_t mask,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf4_m(mask,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16_v_u8mf2_m(vbool16_t mask,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf2_m(mask,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei16_v_u8m1_m(vbool8_t mask,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m1_m(mask,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei16_v_u8m2_m(vbool4_t mask,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m2_m(mask,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vloxei16_v_u8m4_m(vbool2_t mask,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m4_m(mask,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16_v_u16mf4_m(vbool64_t mask,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf4_m(mask,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16_v_u16mf2_m(vbool32_t mask,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf2_m(mask,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei16_v_u16m1_m(vbool16_t mask,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m1_m(mask,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei16_v_u16m2_m(vbool8_t mask,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m2_m(mask,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei16_v_u16m4_m(vbool4_t mask,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m4_m(mask,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vloxei16_v_u16m8_m(vbool2_t mask,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m8_m(mask,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16_v_u32mf2_m(vbool64_t mask,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32mf2_m(mask,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei16_v_u32m1_m(vbool32_t mask,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m1_m(mask,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei16_v_u32m2_m(vbool16_t mask,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m2_m(mask,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei16_v_u32m4_m(vbool8_t mask,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m4_m(mask,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei16_v_u32m8_m(vbool4_t mask,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m8_m(mask,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei16_v_u64m1_m(vbool64_t mask,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m1_m(mask,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei16_v_u64m2_m(vbool32_t mask,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m2_m(mask,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei16_v_u64m4_m(vbool16_t mask,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m4_m(mask,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei16_v_u64m8_m(vbool8_t mask,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m8_m(mask,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16_v_f32mf2_m(vbool64_t mask,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32mf2_m(mask,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16_v_f32m1_m(vbool32_t mask,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m1_m(mask,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16_v_f32m2_m(vbool16_t mask,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m2_m(mask,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16_v_f32m4_m(vbool8_t mask,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m4_m(mask,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16_v_f32m8_m(vbool4_t mask,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m8_m(mask,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16_v_f64m1_m(vbool64_t mask,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m1_m(mask,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16_v_f64m2_m(vbool32_t mask,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m2_m(mask,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16_v_f64m4_m(vbool16_t mask,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m4_m(mask,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16_v_f64m8_m(vbool8_t mask,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m8_m(mask,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_m-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_m-3.c
new file mode 100644
index 0000000..d2fd8a1
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_m-3.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei16_v_i8mf8_m(vbool64_t mask,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf8_m(mask,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei16_v_i8mf4_m(vbool32_t mask,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf4_m(mask,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei16_v_i8mf2_m(vbool16_t mask,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf2_m(mask,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei16_v_i8m1_m(vbool8_t mask,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m1_m(mask,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei16_v_i8m2_m(vbool4_t mask,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m2_m(mask,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vloxei16_v_i8m4_m(vbool2_t mask,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m4_m(mask,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei16_v_i16mf4_m(vbool64_t mask,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf4_m(mask,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei16_v_i16mf2_m(vbool32_t mask,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf2_m(mask,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei16_v_i16m1_m(vbool16_t mask,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m1_m(mask,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei16_v_i16m2_m(vbool8_t mask,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m2_m(mask,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei16_v_i16m4_m(vbool4_t mask,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m4_m(mask,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vloxei16_v_i16m8_m(vbool2_t mask,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m8_m(mask,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei16_v_i32mf2_m(vbool64_t mask,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32mf2_m(mask,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei16_v_i32m1_m(vbool32_t mask,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m1_m(mask,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei16_v_i32m2_m(vbool16_t mask,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m2_m(mask,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei16_v_i32m4_m(vbool8_t mask,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m4_m(mask,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei16_v_i32m8_m(vbool4_t mask,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m8_m(mask,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei16_v_i64m1_m(vbool64_t mask,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m1_m(mask,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei16_v_i64m2_m(vbool32_t mask,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m2_m(mask,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei16_v_i64m4_m(vbool16_t mask,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m4_m(mask,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei16_v_i64m8_m(vbool8_t mask,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m8_m(mask,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16_v_u8mf8_m(vbool64_t mask,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf8_m(mask,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16_v_u8mf4_m(vbool32_t mask,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf4_m(mask,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16_v_u8mf2_m(vbool16_t mask,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf2_m(mask,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei16_v_u8m1_m(vbool8_t mask,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m1_m(mask,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei16_v_u8m2_m(vbool4_t mask,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m2_m(mask,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vloxei16_v_u8m4_m(vbool2_t mask,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m4_m(mask,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16_v_u16mf4_m(vbool64_t mask,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf4_m(mask,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16_v_u16mf2_m(vbool32_t mask,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf2_m(mask,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei16_v_u16m1_m(vbool16_t mask,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m1_m(mask,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei16_v_u16m2_m(vbool8_t mask,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m2_m(mask,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei16_v_u16m4_m(vbool4_t mask,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m4_m(mask,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vloxei16_v_u16m8_m(vbool2_t mask,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m8_m(mask,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16_v_u32mf2_m(vbool64_t mask,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32mf2_m(mask,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei16_v_u32m1_m(vbool32_t mask,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m1_m(mask,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei16_v_u32m2_m(vbool16_t mask,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m2_m(mask,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei16_v_u32m4_m(vbool8_t mask,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m4_m(mask,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei16_v_u32m8_m(vbool4_t mask,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m8_m(mask,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei16_v_u64m1_m(vbool64_t mask,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m1_m(mask,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei16_v_u64m2_m(vbool32_t mask,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m2_m(mask,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei16_v_u64m4_m(vbool16_t mask,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m4_m(mask,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei16_v_u64m8_m(vbool8_t mask,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m8_m(mask,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16_v_f32mf2_m(vbool64_t mask,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32mf2_m(mask,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16_v_f32m1_m(vbool32_t mask,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m1_m(mask,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16_v_f32m2_m(vbool16_t mask,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m2_m(mask,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16_v_f32m4_m(vbool8_t mask,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m4_m(mask,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16_v_f32m8_m(vbool4_t mask,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m8_m(mask,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16_v_f64m1_m(vbool64_t mask,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m1_m(mask,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16_v_f64m2_m(vbool32_t mask,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m2_m(mask,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16_v_f64m4_m(vbool16_t mask,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m4_m(mask,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16_v_f64m8_m(vbool8_t mask,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m8_m(mask,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_mu-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_mu-1.c
new file mode 100644
index 0000000..08dc826
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_mu-1.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei16_v_i8mf8_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei16_v_i8mf4_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei16_v_i8mf2_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei16_v_i8m1_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei16_v_i8m2_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vloxei16_v_i8m4_mu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei16_v_i16mf4_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei16_v_i16mf2_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei16_v_i16m1_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei16_v_i16m2_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei16_v_i16m4_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vloxei16_v_i16m8_mu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei16_v_i32mf2_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei16_v_i32m1_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei16_v_i32m2_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei16_v_i32m4_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei16_v_i32m8_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei16_v_i64m1_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei16_v_i64m2_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei16_v_i64m4_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei16_v_i64m8_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16_v_u8mf8_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16_v_u8mf4_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16_v_u8mf2_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei16_v_u8m1_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei16_v_u8m2_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vloxei16_v_u8m4_mu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16_v_u16mf4_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16_v_u16mf2_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei16_v_u16m1_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei16_v_u16m2_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei16_v_u16m4_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vloxei16_v_u16m8_mu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16_v_u32mf2_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei16_v_u32m1_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei16_v_u32m2_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei16_v_u32m4_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei16_v_u32m8_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei16_v_u64m1_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei16_v_u64m2_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei16_v_u64m4_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei16_v_u64m8_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16_v_f32mf2_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16_v_f32m1_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16_v_f32m2_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16_v_f32m4_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16_v_f32m8_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16_v_f64m1_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16_v_f64m2_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16_v_f64m4_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16_v_f64m8_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_mu-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_mu-2.c
new file mode 100644
index 0000000..b00582a
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_mu-2.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei16_v_i8mf8_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei16_v_i8mf4_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei16_v_i8mf2_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei16_v_i8m1_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei16_v_i8m2_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vloxei16_v_i8m4_mu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei16_v_i16mf4_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei16_v_i16mf2_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei16_v_i16m1_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei16_v_i16m2_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei16_v_i16m4_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vloxei16_v_i16m8_mu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei16_v_i32mf2_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei16_v_i32m1_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei16_v_i32m2_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei16_v_i32m4_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei16_v_i32m8_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei16_v_i64m1_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei16_v_i64m2_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei16_v_i64m4_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei16_v_i64m8_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16_v_u8mf8_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16_v_u8mf4_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16_v_u8mf2_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei16_v_u8m1_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei16_v_u8m2_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vloxei16_v_u8m4_mu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16_v_u16mf4_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16_v_u16mf2_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei16_v_u16m1_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei16_v_u16m2_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei16_v_u16m4_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vloxei16_v_u16m8_mu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16_v_u32mf2_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei16_v_u32m1_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei16_v_u32m2_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei16_v_u32m4_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei16_v_u32m8_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei16_v_u64m1_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei16_v_u64m2_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei16_v_u64m4_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei16_v_u64m8_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16_v_f32mf2_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16_v_f32m1_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16_v_f32m2_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16_v_f32m4_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16_v_f32m8_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16_v_f64m1_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16_v_f64m2_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16_v_f64m4_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16_v_f64m8_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m8_mu(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_mu-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_mu-3.c
new file mode 100644
index 0000000..79f39ab
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_mu-3.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei16_v_i8mf8_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei16_v_i8mf4_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei16_v_i8mf2_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei16_v_i8m1_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei16_v_i8m2_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vloxei16_v_i8m4_mu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei16_v_i16mf4_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei16_v_i16mf2_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei16_v_i16m1_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei16_v_i16m2_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei16_v_i16m4_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vloxei16_v_i16m8_mu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei16_v_i32mf2_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei16_v_i32m1_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei16_v_i32m2_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei16_v_i32m4_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei16_v_i32m8_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei16_v_i64m1_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei16_v_i64m2_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei16_v_i64m4_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei16_v_i64m8_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16_v_u8mf8_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16_v_u8mf4_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16_v_u8mf2_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei16_v_u8m1_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei16_v_u8m2_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vloxei16_v_u8m4_mu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16_v_u16mf4_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16_v_u16mf2_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei16_v_u16m1_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei16_v_u16m2_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei16_v_u16m4_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vloxei16_v_u16m8_mu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16_v_u32mf2_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei16_v_u32m1_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei16_v_u32m2_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei16_v_u32m4_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei16_v_u32m8_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei16_v_u64m1_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei16_v_u64m2_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei16_v_u64m4_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei16_v_u64m8_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16_v_f32mf2_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16_v_f32m1_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16_v_f32m2_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16_v_f32m4_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16_v_f32m8_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16_v_f64m1_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16_v_f64m2_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16_v_f64m4_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16_v_f64m8_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m8_mu(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_tu-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_tu-1.c
new file mode 100644
index 0000000..bae741f
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_tu-1.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei16_v_i8mf8_tu(vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf8_tu(merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei16_v_i8mf4_tu(vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf4_tu(merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei16_v_i8mf2_tu(vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf2_tu(merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei16_v_i8m1_tu(vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m1_tu(merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei16_v_i8m2_tu(vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m2_tu(merge,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vloxei16_v_i8m4_tu(vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m4_tu(merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei16_v_i16mf4_tu(vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf4_tu(merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei16_v_i16mf2_tu(vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf2_tu(merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei16_v_i16m1_tu(vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m1_tu(merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei16_v_i16m2_tu(vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m2_tu(merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei16_v_i16m4_tu(vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m4_tu(merge,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vloxei16_v_i16m8_tu(vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m8_tu(merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei16_v_i32mf2_tu(vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32mf2_tu(merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei16_v_i32m1_tu(vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m1_tu(merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei16_v_i32m2_tu(vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m2_tu(merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei16_v_i32m4_tu(vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m4_tu(merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei16_v_i32m8_tu(vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m8_tu(merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei16_v_i64m1_tu(vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m1_tu(merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei16_v_i64m2_tu(vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m2_tu(merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei16_v_i64m4_tu(vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m4_tu(merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei16_v_i64m8_tu(vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m8_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16_v_u8mf8_tu(vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf8_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16_v_u8mf4_tu(vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf4_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16_v_u8mf2_tu(vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf2_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei16_v_u8m1_tu(vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m1_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei16_v_u8m2_tu(vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m2_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vloxei16_v_u8m4_tu(vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m4_tu(merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16_v_u16mf4_tu(vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf4_tu(merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16_v_u16mf2_tu(vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf2_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei16_v_u16m1_tu(vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m1_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei16_v_u16m2_tu(vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m2_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei16_v_u16m4_tu(vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m4_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vloxei16_v_u16m8_tu(vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m8_tu(merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16_v_u32mf2_tu(vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32mf2_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei16_v_u32m1_tu(vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m1_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei16_v_u32m2_tu(vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m2_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei16_v_u32m4_tu(vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m4_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei16_v_u32m8_tu(vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m8_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei16_v_u64m1_tu(vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m1_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei16_v_u64m2_tu(vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m2_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei16_v_u64m4_tu(vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m4_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei16_v_u64m8_tu(vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m8_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16_v_f32mf2_tu(vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32mf2_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16_v_f32m1_tu(vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m1_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16_v_f32m2_tu(vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m2_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16_v_f32m4_tu(vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m4_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16_v_f32m8_tu(vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m8_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16_v_f64m1_tu(vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m1_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16_v_f64m2_tu(vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m2_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16_v_f64m4_tu(vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m4_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16_v_f64m8_tu(vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m8_tu(merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_tu-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_tu-2.c
new file mode 100644
index 0000000..1221b10
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_tu-2.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei16_v_i8mf8_tu(vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf8_tu(merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei16_v_i8mf4_tu(vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf4_tu(merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei16_v_i8mf2_tu(vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf2_tu(merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei16_v_i8m1_tu(vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m1_tu(merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei16_v_i8m2_tu(vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m2_tu(merge,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vloxei16_v_i8m4_tu(vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m4_tu(merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei16_v_i16mf4_tu(vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf4_tu(merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei16_v_i16mf2_tu(vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf2_tu(merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei16_v_i16m1_tu(vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m1_tu(merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei16_v_i16m2_tu(vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m2_tu(merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei16_v_i16m4_tu(vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m4_tu(merge,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vloxei16_v_i16m8_tu(vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m8_tu(merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei16_v_i32mf2_tu(vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32mf2_tu(merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei16_v_i32m1_tu(vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m1_tu(merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei16_v_i32m2_tu(vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m2_tu(merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei16_v_i32m4_tu(vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m4_tu(merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei16_v_i32m8_tu(vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m8_tu(merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei16_v_i64m1_tu(vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m1_tu(merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei16_v_i64m2_tu(vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m2_tu(merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei16_v_i64m4_tu(vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m4_tu(merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei16_v_i64m8_tu(vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m8_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16_v_u8mf8_tu(vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf8_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16_v_u8mf4_tu(vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf4_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16_v_u8mf2_tu(vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf2_tu(merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei16_v_u8m1_tu(vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m1_tu(merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei16_v_u8m2_tu(vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m2_tu(merge,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vloxei16_v_u8m4_tu(vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m4_tu(merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16_v_u16mf4_tu(vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf4_tu(merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16_v_u16mf2_tu(vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf2_tu(merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei16_v_u16m1_tu(vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m1_tu(merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei16_v_u16m2_tu(vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m2_tu(merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei16_v_u16m4_tu(vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m4_tu(merge,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vloxei16_v_u16m8_tu(vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m8_tu(merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16_v_u32mf2_tu(vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32mf2_tu(merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei16_v_u32m1_tu(vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m1_tu(merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei16_v_u32m2_tu(vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m2_tu(merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei16_v_u32m4_tu(vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m4_tu(merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei16_v_u32m8_tu(vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m8_tu(merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei16_v_u64m1_tu(vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m1_tu(merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei16_v_u64m2_tu(vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m2_tu(merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei16_v_u64m4_tu(vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m4_tu(merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei16_v_u64m8_tu(vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m8_tu(merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16_v_f32mf2_tu(vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32mf2_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16_v_f32m1_tu(vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m1_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16_v_f32m2_tu(vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m2_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16_v_f32m4_tu(vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m4_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16_v_f32m8_tu(vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m8_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16_v_f64m1_tu(vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m1_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16_v_f64m2_tu(vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m2_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16_v_f64m4_tu(vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m4_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16_v_f64m8_tu(vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m8_tu(merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_tu-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_tu-3.c
new file mode 100644
index 0000000..24f231b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_tu-3.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei16_v_i8mf8_tu(vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf8_tu(merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei16_v_i8mf4_tu(vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf4_tu(merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei16_v_i8mf2_tu(vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf2_tu(merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei16_v_i8m1_tu(vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m1_tu(merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei16_v_i8m2_tu(vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m2_tu(merge,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vloxei16_v_i8m4_tu(vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m4_tu(merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei16_v_i16mf4_tu(vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf4_tu(merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei16_v_i16mf2_tu(vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf2_tu(merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei16_v_i16m1_tu(vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m1_tu(merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei16_v_i16m2_tu(vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m2_tu(merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei16_v_i16m4_tu(vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m4_tu(merge,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vloxei16_v_i16m8_tu(vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m8_tu(merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei16_v_i32mf2_tu(vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32mf2_tu(merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei16_v_i32m1_tu(vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m1_tu(merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei16_v_i32m2_tu(vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m2_tu(merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei16_v_i32m4_tu(vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m4_tu(merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei16_v_i32m8_tu(vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m8_tu(merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei16_v_i64m1_tu(vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m1_tu(merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei16_v_i64m2_tu(vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m2_tu(merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei16_v_i64m4_tu(vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m4_tu(merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei16_v_i64m8_tu(vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m8_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16_v_u8mf8_tu(vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf8_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16_v_u8mf4_tu(vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf4_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16_v_u8mf2_tu(vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf2_tu(merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei16_v_u8m1_tu(vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m1_tu(merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei16_v_u8m2_tu(vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m2_tu(merge,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vloxei16_v_u8m4_tu(vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m4_tu(merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16_v_u16mf4_tu(vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf4_tu(merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16_v_u16mf2_tu(vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf2_tu(merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei16_v_u16m1_tu(vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m1_tu(merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei16_v_u16m2_tu(vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m2_tu(merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei16_v_u16m4_tu(vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m4_tu(merge,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vloxei16_v_u16m8_tu(vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m8_tu(merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16_v_u32mf2_tu(vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32mf2_tu(merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei16_v_u32m1_tu(vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m1_tu(merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei16_v_u32m2_tu(vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m2_tu(merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei16_v_u32m4_tu(vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m4_tu(merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei16_v_u32m8_tu(vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m8_tu(merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei16_v_u64m1_tu(vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m1_tu(merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei16_v_u64m2_tu(vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m2_tu(merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei16_v_u64m4_tu(vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m4_tu(merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei16_v_u64m8_tu(vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m8_tu(merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16_v_f32mf2_tu(vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32mf2_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16_v_f32m1_tu(vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m1_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16_v_f32m2_tu(vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m2_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16_v_f32m4_tu(vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m4_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16_v_f32m8_tu(vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m8_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16_v_f64m1_tu(vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m1_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16_v_f64m2_tu(vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m2_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16_v_f64m4_tu(vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m4_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16_v_f64m8_tu(vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m8_tu(merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_tum-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_tum-1.c
new file mode 100644
index 0000000..2b96c49
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_tum-1.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei16_v_i8mf8_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei16_v_i8mf4_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei16_v_i8mf2_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei16_v_i8m1_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei16_v_i8m2_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vloxei16_v_i8m4_tum(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei16_v_i16mf4_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei16_v_i16mf2_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei16_v_i16m1_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei16_v_i16m2_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei16_v_i16m4_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vloxei16_v_i16m8_tum(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei16_v_i32mf2_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei16_v_i32m1_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei16_v_i32m2_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei16_v_i32m4_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei16_v_i32m8_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei16_v_i64m1_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei16_v_i64m2_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei16_v_i64m4_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei16_v_i64m8_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16_v_u8mf8_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16_v_u8mf4_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16_v_u8mf2_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei16_v_u8m1_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei16_v_u8m2_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vloxei16_v_u8m4_tum(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16_v_u16mf4_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16_v_u16mf2_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei16_v_u16m1_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei16_v_u16m2_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei16_v_u16m4_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vloxei16_v_u16m8_tum(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16_v_u32mf2_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei16_v_u32m1_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei16_v_u32m2_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei16_v_u32m4_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei16_v_u32m8_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei16_v_u64m1_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei16_v_u64m2_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei16_v_u64m4_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei16_v_u64m8_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16_v_f32mf2_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16_v_f32m1_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16_v_f32m2_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16_v_f32m4_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16_v_f32m8_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16_v_f64m1_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16_v_f64m2_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16_v_f64m4_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16_v_f64m8_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_tum-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_tum-2.c
new file mode 100644
index 0000000..f6072cd
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_tum-2.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei16_v_i8mf8_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei16_v_i8mf4_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei16_v_i8mf2_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei16_v_i8m1_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei16_v_i8m2_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vloxei16_v_i8m4_tum(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei16_v_i16mf4_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei16_v_i16mf2_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei16_v_i16m1_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei16_v_i16m2_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei16_v_i16m4_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vloxei16_v_i16m8_tum(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei16_v_i32mf2_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei16_v_i32m1_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei16_v_i32m2_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei16_v_i32m4_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei16_v_i32m8_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei16_v_i64m1_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei16_v_i64m2_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei16_v_i64m4_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei16_v_i64m8_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16_v_u8mf8_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16_v_u8mf4_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16_v_u8mf2_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei16_v_u8m1_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei16_v_u8m2_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vloxei16_v_u8m4_tum(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16_v_u16mf4_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16_v_u16mf2_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei16_v_u16m1_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei16_v_u16m2_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei16_v_u16m4_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vloxei16_v_u16m8_tum(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16_v_u32mf2_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei16_v_u32m1_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei16_v_u32m2_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei16_v_u32m4_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei16_v_u32m8_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei16_v_u64m1_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei16_v_u64m2_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei16_v_u64m4_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei16_v_u64m8_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16_v_f32mf2_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16_v_f32m1_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16_v_f32m2_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16_v_f32m4_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16_v_f32m8_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16_v_f64m1_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16_v_f64m2_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16_v_f64m4_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16_v_f64m8_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m8_tum(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_tum-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_tum-3.c
new file mode 100644
index 0000000..a70bbac
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_tum-3.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei16_v_i8mf8_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei16_v_i8mf4_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei16_v_i8mf2_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei16_v_i8m1_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei16_v_i8m2_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vloxei16_v_i8m4_tum(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei16_v_i16mf4_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei16_v_i16mf2_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei16_v_i16m1_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei16_v_i16m2_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei16_v_i16m4_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vloxei16_v_i16m8_tum(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei16_v_i32mf2_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei16_v_i32m1_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei16_v_i32m2_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei16_v_i32m4_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei16_v_i32m8_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei16_v_i64m1_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei16_v_i64m2_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei16_v_i64m4_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei16_v_i64m8_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16_v_u8mf8_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16_v_u8mf4_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16_v_u8mf2_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei16_v_u8m1_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei16_v_u8m2_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vloxei16_v_u8m4_tum(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16_v_u16mf4_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16_v_u16mf2_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei16_v_u16m1_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei16_v_u16m2_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei16_v_u16m4_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vloxei16_v_u16m8_tum(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16_v_u32mf2_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei16_v_u32m1_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei16_v_u32m2_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei16_v_u32m4_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei16_v_u32m8_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei16_v_u64m1_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei16_v_u64m2_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei16_v_u64m4_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei16_v_u64m8_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16_v_f32mf2_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16_v_f32m1_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16_v_f32m2_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16_v_f32m4_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16_v_f32m8_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16_v_f64m1_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16_v_f64m2_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16_v_f64m4_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16_v_f64m8_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m8_tum(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_tumu-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_tumu-1.c
new file mode 100644
index 0000000..85acfd0
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_tumu-1.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei16_v_i8mf8_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei16_v_i8mf4_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei16_v_i8mf2_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei16_v_i8m1_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei16_v_i8m2_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vloxei16_v_i8m4_tumu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei16_v_i16mf4_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei16_v_i16mf2_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei16_v_i16m1_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei16_v_i16m2_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei16_v_i16m4_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vloxei16_v_i16m8_tumu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei16_v_i32mf2_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei16_v_i32m1_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei16_v_i32m2_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei16_v_i32m4_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei16_v_i32m8_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei16_v_i64m1_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei16_v_i64m2_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei16_v_i64m4_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei16_v_i64m8_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16_v_u8mf8_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16_v_u8mf4_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16_v_u8mf2_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei16_v_u8m1_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei16_v_u8m2_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vloxei16_v_u8m4_tumu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16_v_u16mf4_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16_v_u16mf2_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei16_v_u16m1_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei16_v_u16m2_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei16_v_u16m4_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vloxei16_v_u16m8_tumu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16_v_u32mf2_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei16_v_u32m1_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei16_v_u32m2_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei16_v_u32m4_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei16_v_u32m8_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei16_v_u64m1_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei16_v_u64m2_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei16_v_u64m4_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei16_v_u64m8_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16_v_f32mf2_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16_v_f32m1_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16_v_f32m2_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16_v_f32m4_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16_v_f32m8_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16_v_f64m1_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16_v_f64m2_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16_v_f64m4_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16_v_f64m8_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_tumu-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_tumu-2.c
new file mode 100644
index 0000000..f117035
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_tumu-2.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei16_v_i8mf8_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei16_v_i8mf4_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei16_v_i8mf2_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei16_v_i8m1_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei16_v_i8m2_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vloxei16_v_i8m4_tumu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei16_v_i16mf4_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei16_v_i16mf2_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei16_v_i16m1_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei16_v_i16m2_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei16_v_i16m4_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vloxei16_v_i16m8_tumu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei16_v_i32mf2_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei16_v_i32m1_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei16_v_i32m2_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei16_v_i32m4_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei16_v_i32m8_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei16_v_i64m1_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei16_v_i64m2_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei16_v_i64m4_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei16_v_i64m8_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16_v_u8mf8_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16_v_u8mf4_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16_v_u8mf2_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei16_v_u8m1_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei16_v_u8m2_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vloxei16_v_u8m4_tumu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16_v_u16mf4_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16_v_u16mf2_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei16_v_u16m1_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei16_v_u16m2_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei16_v_u16m4_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vloxei16_v_u16m8_tumu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16_v_u32mf2_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei16_v_u32m1_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei16_v_u32m2_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei16_v_u32m4_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei16_v_u32m8_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei16_v_u64m1_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei16_v_u64m2_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei16_v_u64m4_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei16_v_u64m8_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16_v_f32mf2_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16_v_f32m1_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16_v_f32m2_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16_v_f32m4_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16_v_f32m8_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16_v_f64m1_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16_v_f64m2_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16_v_f64m4_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16_v_f64m8_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_tumu-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_tumu-3.c
new file mode 100644
index 0000000..69120d2d
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei16_v_tumu-3.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei16_v_i8mf8_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei16_v_i8mf4_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei16_v_i8mf2_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei16_v_i8m1_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei16_v_i8m2_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vloxei16_v_i8m4_tumu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i8m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei16_v_i16mf4_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei16_v_i16mf2_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei16_v_i16m1_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei16_v_i16m2_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei16_v_i16m4_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vloxei16_v_i16m8_tumu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i16m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei16_v_i32mf2_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei16_v_i32m1_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei16_v_i32m2_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei16_v_i32m4_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei16_v_i32m8_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i32m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei16_v_i64m1_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei16_v_i64m2_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei16_v_i64m4_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei16_v_i64m8_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_i64m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei16_v_u8mf8_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei16_v_u8mf4_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei16_v_u8mf2_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei16_v_u8m1_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei16_v_u8m2_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vloxei16_v_u8m4_tumu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u8m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei16_v_u16mf4_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei16_v_u16mf2_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei16_v_u16m1_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei16_v_u16m2_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei16_v_u16m4_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vloxei16_v_u16m8_tumu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u16m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei16_v_u32mf2_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei16_v_u32m1_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei16_v_u32m2_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei16_v_u32m4_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei16_v_u32m8_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u32m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei16_v_u64m1_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei16_v_u64m2_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei16_v_u64m4_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei16_v_u64m8_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_u64m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei16_v_f32mf2_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei16_v_f32m1_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei16_v_f32m2_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei16_v_f32m4_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei16_v_f32m8_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f32m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei16_v_f64m1_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei16_v_f64m2_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei16_v_f64m4_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei16_v_f64m8_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei16_v_f64m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vloxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v-1.c
new file mode 100644
index 0000000..8d82174
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v-1.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei32_v_i8mf8(const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf8(base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei32_v_i8mf4(const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf4(base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei32_v_i8mf2(const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf2(base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei32_v_i8m1(const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m1(base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei32_v_i8m2(const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m2(base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei32_v_i16mf4(const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf4(base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei32_v_i16mf2(const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf2(base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei32_v_i16m1(const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m1(base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei32_v_i16m2(const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m2(base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei32_v_i16m4(const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m4(base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei32_v_i32mf2(const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32mf2(base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei32_v_i32m1(const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m1(base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei32_v_i32m2(const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m2(base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei32_v_i32m4(const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m4(base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei32_v_i32m8(const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m8(base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei32_v_i64m1(const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m1(base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei32_v_i64m2(const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m2(base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei32_v_i64m4(const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m4(base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei32_v_i64m8(const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m8(base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32_v_u8mf8(const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf8(base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32_v_u8mf4(const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf4(base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32_v_u8mf2(const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf2(base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei32_v_u8m1(const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m1(base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei32_v_u8m2(const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m2(base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32_v_u16mf4(const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf4(base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32_v_u16mf2(const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf2(base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei32_v_u16m1(const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m1(base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei32_v_u16m2(const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m2(base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei32_v_u16m4(const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m4(base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32_v_u32mf2(const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32mf2(base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei32_v_u32m1(const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m1(base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei32_v_u32m2(const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m2(base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei32_v_u32m4(const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m4(base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei32_v_u32m8(const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m8(base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei32_v_u64m1(const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m1(base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei32_v_u64m2(const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m2(base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei32_v_u64m4(const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m4(base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei32_v_u64m8(const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m8(base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32_v_f32mf2(const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32mf2(base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32_v_f32m1(const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m1(base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32_v_f32m2(const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m2(base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32_v_f32m4(const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m4(base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32_v_f32m8(const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m8(base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32_v_f64m1(const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m1(base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32_v_f64m2(const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m2(base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32_v_f64m4(const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m4(base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32_v_f64m8(const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m8(base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v-2.c
new file mode 100644
index 0000000..267eb8c
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v-2.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei32_v_i8mf8(const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf8(base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei32_v_i8mf4(const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf4(base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei32_v_i8mf2(const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf2(base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei32_v_i8m1(const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m1(base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei32_v_i8m2(const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m2(base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei32_v_i16mf4(const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf4(base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei32_v_i16mf2(const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf2(base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei32_v_i16m1(const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m1(base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei32_v_i16m2(const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m2(base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei32_v_i16m4(const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m4(base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei32_v_i32mf2(const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32mf2(base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei32_v_i32m1(const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m1(base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei32_v_i32m2(const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m2(base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei32_v_i32m4(const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m4(base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei32_v_i32m8(const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m8(base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei32_v_i64m1(const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m1(base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei32_v_i64m2(const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m2(base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei32_v_i64m4(const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m4(base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei32_v_i64m8(const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m8(base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32_v_u8mf8(const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf8(base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32_v_u8mf4(const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf4(base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32_v_u8mf2(const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf2(base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei32_v_u8m1(const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m1(base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei32_v_u8m2(const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m2(base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32_v_u16mf4(const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf4(base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32_v_u16mf2(const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf2(base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei32_v_u16m1(const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m1(base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei32_v_u16m2(const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m2(base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei32_v_u16m4(const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m4(base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32_v_u32mf2(const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32mf2(base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei32_v_u32m1(const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m1(base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei32_v_u32m2(const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m2(base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei32_v_u32m4(const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m4(base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei32_v_u32m8(const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m8(base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei32_v_u64m1(const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m1(base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei32_v_u64m2(const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m2(base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei32_v_u64m4(const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m4(base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei32_v_u64m8(const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m8(base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32_v_f32mf2(const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32mf2(base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32_v_f32m1(const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m1(base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32_v_f32m2(const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m2(base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32_v_f32m4(const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m4(base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32_v_f32m8(const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m8(base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32_v_f64m1(const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m1(base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32_v_f64m2(const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m2(base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32_v_f64m4(const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m4(base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32_v_f64m8(const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m8(base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v-3.c
new file mode 100644
index 0000000..494fc47
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v-3.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei32_v_i8mf8(const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf8(base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei32_v_i8mf4(const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf4(base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei32_v_i8mf2(const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf2(base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei32_v_i8m1(const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m1(base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei32_v_i8m2(const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m2(base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei32_v_i16mf4(const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf4(base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei32_v_i16mf2(const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf2(base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei32_v_i16m1(const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m1(base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei32_v_i16m2(const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m2(base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei32_v_i16m4(const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m4(base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei32_v_i32mf2(const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32mf2(base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei32_v_i32m1(const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m1(base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei32_v_i32m2(const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m2(base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei32_v_i32m4(const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m4(base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei32_v_i32m8(const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m8(base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei32_v_i64m1(const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m1(base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei32_v_i64m2(const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m2(base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei32_v_i64m4(const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m4(base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei32_v_i64m8(const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m8(base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32_v_u8mf8(const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf8(base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32_v_u8mf4(const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf4(base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32_v_u8mf2(const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf2(base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei32_v_u8m1(const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m1(base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei32_v_u8m2(const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m2(base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32_v_u16mf4(const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf4(base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32_v_u16mf2(const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf2(base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei32_v_u16m1(const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m1(base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei32_v_u16m2(const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m2(base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei32_v_u16m4(const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m4(base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32_v_u32mf2(const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32mf2(base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei32_v_u32m1(const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m1(base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei32_v_u32m2(const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m2(base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei32_v_u32m4(const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m4(base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei32_v_u32m8(const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m8(base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei32_v_u64m1(const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m1(base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei32_v_u64m2(const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m2(base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei32_v_u64m4(const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m4(base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei32_v_u64m8(const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m8(base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32_v_f32mf2(const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32mf2(base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32_v_f32m1(const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m1(base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32_v_f32m2(const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m2(base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32_v_f32m4(const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m4(base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32_v_f32m8(const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m8(base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32_v_f64m1(const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m1(base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32_v_f64m2(const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m2(base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32_v_f64m4(const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m4(base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32_v_f64m8(const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m8(base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_m-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_m-1.c
new file mode 100644
index 0000000..8d8cd05
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_m-1.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei32_v_i8mf8_m(vbool64_t mask,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf8_m(mask,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei32_v_i8mf4_m(vbool32_t mask,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf4_m(mask,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei32_v_i8mf2_m(vbool16_t mask,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf2_m(mask,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei32_v_i8m1_m(vbool8_t mask,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m1_m(mask,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei32_v_i8m2_m(vbool4_t mask,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m2_m(mask,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei32_v_i16mf4_m(vbool64_t mask,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf4_m(mask,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei32_v_i16mf2_m(vbool32_t mask,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf2_m(mask,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei32_v_i16m1_m(vbool16_t mask,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m1_m(mask,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei32_v_i16m2_m(vbool8_t mask,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m2_m(mask,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei32_v_i16m4_m(vbool4_t mask,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m4_m(mask,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei32_v_i32mf2_m(vbool64_t mask,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32mf2_m(mask,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei32_v_i32m1_m(vbool32_t mask,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m1_m(mask,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei32_v_i32m2_m(vbool16_t mask,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m2_m(mask,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei32_v_i32m4_m(vbool8_t mask,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m4_m(mask,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei32_v_i32m8_m(vbool4_t mask,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m8_m(mask,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei32_v_i64m1_m(vbool64_t mask,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m1_m(mask,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei32_v_i64m2_m(vbool32_t mask,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m2_m(mask,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei32_v_i64m4_m(vbool16_t mask,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m4_m(mask,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei32_v_i64m8_m(vbool8_t mask,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m8_m(mask,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32_v_u8mf8_m(vbool64_t mask,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf8_m(mask,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32_v_u8mf4_m(vbool32_t mask,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf4_m(mask,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32_v_u8mf2_m(vbool16_t mask,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf2_m(mask,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei32_v_u8m1_m(vbool8_t mask,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m1_m(mask,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei32_v_u8m2_m(vbool4_t mask,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m2_m(mask,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32_v_u16mf4_m(vbool64_t mask,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf4_m(mask,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32_v_u16mf2_m(vbool32_t mask,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf2_m(mask,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei32_v_u16m1_m(vbool16_t mask,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m1_m(mask,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei32_v_u16m2_m(vbool8_t mask,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m2_m(mask,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei32_v_u16m4_m(vbool4_t mask,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m4_m(mask,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32_v_u32mf2_m(vbool64_t mask,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32mf2_m(mask,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei32_v_u32m1_m(vbool32_t mask,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m1_m(mask,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei32_v_u32m2_m(vbool16_t mask,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m2_m(mask,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei32_v_u32m4_m(vbool8_t mask,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m4_m(mask,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei32_v_u32m8_m(vbool4_t mask,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m8_m(mask,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei32_v_u64m1_m(vbool64_t mask,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m1_m(mask,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei32_v_u64m2_m(vbool32_t mask,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m2_m(mask,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei32_v_u64m4_m(vbool16_t mask,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m4_m(mask,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei32_v_u64m8_m(vbool8_t mask,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m8_m(mask,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32_v_f32mf2_m(vbool64_t mask,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32mf2_m(mask,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32_v_f32m1_m(vbool32_t mask,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m1_m(mask,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32_v_f32m2_m(vbool16_t mask,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m2_m(mask,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32_v_f32m4_m(vbool8_t mask,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m4_m(mask,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32_v_f32m8_m(vbool4_t mask,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m8_m(mask,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32_v_f64m1_m(vbool64_t mask,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m1_m(mask,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32_v_f64m2_m(vbool32_t mask,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m2_m(mask,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32_v_f64m4_m(vbool16_t mask,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m4_m(mask,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32_v_f64m8_m(vbool8_t mask,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m8_m(mask,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_m-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_m-2.c
new file mode 100644
index 0000000..d5afe33
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_m-2.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei32_v_i8mf8_m(vbool64_t mask,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf8_m(mask,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei32_v_i8mf4_m(vbool32_t mask,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf4_m(mask,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei32_v_i8mf2_m(vbool16_t mask,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf2_m(mask,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei32_v_i8m1_m(vbool8_t mask,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m1_m(mask,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei32_v_i8m2_m(vbool4_t mask,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m2_m(mask,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei32_v_i16mf4_m(vbool64_t mask,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf4_m(mask,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei32_v_i16mf2_m(vbool32_t mask,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf2_m(mask,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei32_v_i16m1_m(vbool16_t mask,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m1_m(mask,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei32_v_i16m2_m(vbool8_t mask,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m2_m(mask,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei32_v_i16m4_m(vbool4_t mask,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m4_m(mask,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei32_v_i32mf2_m(vbool64_t mask,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32mf2_m(mask,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei32_v_i32m1_m(vbool32_t mask,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m1_m(mask,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei32_v_i32m2_m(vbool16_t mask,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m2_m(mask,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei32_v_i32m4_m(vbool8_t mask,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m4_m(mask,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei32_v_i32m8_m(vbool4_t mask,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m8_m(mask,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei32_v_i64m1_m(vbool64_t mask,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m1_m(mask,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei32_v_i64m2_m(vbool32_t mask,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m2_m(mask,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei32_v_i64m4_m(vbool16_t mask,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m4_m(mask,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei32_v_i64m8_m(vbool8_t mask,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m8_m(mask,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32_v_u8mf8_m(vbool64_t mask,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf8_m(mask,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32_v_u8mf4_m(vbool32_t mask,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf4_m(mask,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32_v_u8mf2_m(vbool16_t mask,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf2_m(mask,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei32_v_u8m1_m(vbool8_t mask,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m1_m(mask,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei32_v_u8m2_m(vbool4_t mask,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m2_m(mask,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32_v_u16mf4_m(vbool64_t mask,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf4_m(mask,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32_v_u16mf2_m(vbool32_t mask,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf2_m(mask,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei32_v_u16m1_m(vbool16_t mask,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m1_m(mask,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei32_v_u16m2_m(vbool8_t mask,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m2_m(mask,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei32_v_u16m4_m(vbool4_t mask,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m4_m(mask,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32_v_u32mf2_m(vbool64_t mask,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32mf2_m(mask,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei32_v_u32m1_m(vbool32_t mask,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m1_m(mask,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei32_v_u32m2_m(vbool16_t mask,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m2_m(mask,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei32_v_u32m4_m(vbool8_t mask,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m4_m(mask,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei32_v_u32m8_m(vbool4_t mask,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m8_m(mask,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei32_v_u64m1_m(vbool64_t mask,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m1_m(mask,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei32_v_u64m2_m(vbool32_t mask,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m2_m(mask,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei32_v_u64m4_m(vbool16_t mask,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m4_m(mask,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei32_v_u64m8_m(vbool8_t mask,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m8_m(mask,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32_v_f32mf2_m(vbool64_t mask,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32mf2_m(mask,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32_v_f32m1_m(vbool32_t mask,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m1_m(mask,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32_v_f32m2_m(vbool16_t mask,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m2_m(mask,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32_v_f32m4_m(vbool8_t mask,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m4_m(mask,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32_v_f32m8_m(vbool4_t mask,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m8_m(mask,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32_v_f64m1_m(vbool64_t mask,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m1_m(mask,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32_v_f64m2_m(vbool32_t mask,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m2_m(mask,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32_v_f64m4_m(vbool16_t mask,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m4_m(mask,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32_v_f64m8_m(vbool8_t mask,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m8_m(mask,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_m-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_m-3.c
new file mode 100644
index 0000000..cc0b5ee
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_m-3.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei32_v_i8mf8_m(vbool64_t mask,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf8_m(mask,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei32_v_i8mf4_m(vbool32_t mask,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf4_m(mask,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei32_v_i8mf2_m(vbool16_t mask,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf2_m(mask,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei32_v_i8m1_m(vbool8_t mask,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m1_m(mask,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei32_v_i8m2_m(vbool4_t mask,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m2_m(mask,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei32_v_i16mf4_m(vbool64_t mask,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf4_m(mask,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei32_v_i16mf2_m(vbool32_t mask,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf2_m(mask,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei32_v_i16m1_m(vbool16_t mask,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m1_m(mask,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei32_v_i16m2_m(vbool8_t mask,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m2_m(mask,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei32_v_i16m4_m(vbool4_t mask,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m4_m(mask,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei32_v_i32mf2_m(vbool64_t mask,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32mf2_m(mask,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei32_v_i32m1_m(vbool32_t mask,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m1_m(mask,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei32_v_i32m2_m(vbool16_t mask,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m2_m(mask,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei32_v_i32m4_m(vbool8_t mask,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m4_m(mask,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei32_v_i32m8_m(vbool4_t mask,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m8_m(mask,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei32_v_i64m1_m(vbool64_t mask,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m1_m(mask,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei32_v_i64m2_m(vbool32_t mask,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m2_m(mask,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei32_v_i64m4_m(vbool16_t mask,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m4_m(mask,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei32_v_i64m8_m(vbool8_t mask,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m8_m(mask,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32_v_u8mf8_m(vbool64_t mask,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf8_m(mask,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32_v_u8mf4_m(vbool32_t mask,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf4_m(mask,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32_v_u8mf2_m(vbool16_t mask,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf2_m(mask,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei32_v_u8m1_m(vbool8_t mask,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m1_m(mask,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei32_v_u8m2_m(vbool4_t mask,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m2_m(mask,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32_v_u16mf4_m(vbool64_t mask,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf4_m(mask,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32_v_u16mf2_m(vbool32_t mask,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf2_m(mask,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei32_v_u16m1_m(vbool16_t mask,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m1_m(mask,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei32_v_u16m2_m(vbool8_t mask,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m2_m(mask,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei32_v_u16m4_m(vbool4_t mask,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m4_m(mask,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32_v_u32mf2_m(vbool64_t mask,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32mf2_m(mask,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei32_v_u32m1_m(vbool32_t mask,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m1_m(mask,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei32_v_u32m2_m(vbool16_t mask,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m2_m(mask,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei32_v_u32m4_m(vbool8_t mask,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m4_m(mask,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei32_v_u32m8_m(vbool4_t mask,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m8_m(mask,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei32_v_u64m1_m(vbool64_t mask,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m1_m(mask,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei32_v_u64m2_m(vbool32_t mask,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m2_m(mask,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei32_v_u64m4_m(vbool16_t mask,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m4_m(mask,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei32_v_u64m8_m(vbool8_t mask,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m8_m(mask,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32_v_f32mf2_m(vbool64_t mask,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32mf2_m(mask,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32_v_f32m1_m(vbool32_t mask,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m1_m(mask,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32_v_f32m2_m(vbool16_t mask,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m2_m(mask,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32_v_f32m4_m(vbool8_t mask,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m4_m(mask,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32_v_f32m8_m(vbool4_t mask,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m8_m(mask,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32_v_f64m1_m(vbool64_t mask,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m1_m(mask,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32_v_f64m2_m(vbool32_t mask,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m2_m(mask,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32_v_f64m4_m(vbool16_t mask,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m4_m(mask,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32_v_f64m8_m(vbool8_t mask,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m8_m(mask,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_mu-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_mu-1.c
new file mode 100644
index 0000000..d90a302
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_mu-1.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei32_v_i8mf8_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei32_v_i8mf4_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei32_v_i8mf2_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei32_v_i8m1_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei32_v_i8m2_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei32_v_i16mf4_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei32_v_i16mf2_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei32_v_i16m1_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei32_v_i16m2_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei32_v_i16m4_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei32_v_i32mf2_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei32_v_i32m1_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei32_v_i32m2_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei32_v_i32m4_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei32_v_i32m8_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei32_v_i64m1_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei32_v_i64m2_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei32_v_i64m4_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei32_v_i64m8_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32_v_u8mf8_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32_v_u8mf4_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32_v_u8mf2_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei32_v_u8m1_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei32_v_u8m2_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32_v_u16mf4_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32_v_u16mf2_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei32_v_u16m1_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei32_v_u16m2_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei32_v_u16m4_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32_v_u32mf2_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei32_v_u32m1_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei32_v_u32m2_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei32_v_u32m4_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei32_v_u32m8_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei32_v_u64m1_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei32_v_u64m2_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei32_v_u64m4_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei32_v_u64m8_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32_v_f32mf2_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32_v_f32m1_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32_v_f32m2_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32_v_f32m4_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32_v_f32m8_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32_v_f64m1_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32_v_f64m2_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32_v_f64m4_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32_v_f64m8_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_mu-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_mu-2.c
new file mode 100644
index 0000000..2125e26
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_mu-2.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei32_v_i8mf8_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei32_v_i8mf4_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei32_v_i8mf2_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei32_v_i8m1_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei32_v_i8m2_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei32_v_i16mf4_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei32_v_i16mf2_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei32_v_i16m1_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei32_v_i16m2_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei32_v_i16m4_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei32_v_i32mf2_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei32_v_i32m1_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei32_v_i32m2_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei32_v_i32m4_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei32_v_i32m8_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei32_v_i64m1_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei32_v_i64m2_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei32_v_i64m4_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei32_v_i64m8_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32_v_u8mf8_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32_v_u8mf4_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32_v_u8mf2_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei32_v_u8m1_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei32_v_u8m2_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32_v_u16mf4_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32_v_u16mf2_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei32_v_u16m1_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei32_v_u16m2_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei32_v_u16m4_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32_v_u32mf2_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei32_v_u32m1_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei32_v_u32m2_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei32_v_u32m4_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei32_v_u32m8_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei32_v_u64m1_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei32_v_u64m2_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei32_v_u64m4_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei32_v_u64m8_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32_v_f32mf2_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32_v_f32m1_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32_v_f32m2_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32_v_f32m4_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32_v_f32m8_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32_v_f64m1_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32_v_f64m2_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32_v_f64m4_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32_v_f64m8_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m8_mu(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_mu-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_mu-3.c
new file mode 100644
index 0000000..6a339aaf
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_mu-3.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei32_v_i8mf8_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei32_v_i8mf4_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei32_v_i8mf2_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei32_v_i8m1_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei32_v_i8m2_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei32_v_i16mf4_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei32_v_i16mf2_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei32_v_i16m1_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei32_v_i16m2_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei32_v_i16m4_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei32_v_i32mf2_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei32_v_i32m1_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei32_v_i32m2_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei32_v_i32m4_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei32_v_i32m8_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei32_v_i64m1_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei32_v_i64m2_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei32_v_i64m4_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei32_v_i64m8_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32_v_u8mf8_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32_v_u8mf4_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32_v_u8mf2_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei32_v_u8m1_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei32_v_u8m2_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32_v_u16mf4_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32_v_u16mf2_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei32_v_u16m1_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei32_v_u16m2_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei32_v_u16m4_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32_v_u32mf2_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei32_v_u32m1_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei32_v_u32m2_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei32_v_u32m4_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei32_v_u32m8_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei32_v_u64m1_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei32_v_u64m2_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei32_v_u64m4_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei32_v_u64m8_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32_v_f32mf2_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32_v_f32m1_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32_v_f32m2_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32_v_f32m4_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32_v_f32m8_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32_v_f64m1_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32_v_f64m2_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32_v_f64m4_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32_v_f64m8_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m8_mu(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_tu-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_tu-1.c
new file mode 100644
index 0000000..d97b124
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_tu-1.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei32_v_i8mf8_tu(vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf8_tu(merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei32_v_i8mf4_tu(vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf4_tu(merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei32_v_i8mf2_tu(vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf2_tu(merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei32_v_i8m1_tu(vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m1_tu(merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei32_v_i8m2_tu(vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m2_tu(merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei32_v_i16mf4_tu(vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf4_tu(merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei32_v_i16mf2_tu(vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf2_tu(merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei32_v_i16m1_tu(vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m1_tu(merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei32_v_i16m2_tu(vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m2_tu(merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei32_v_i16m4_tu(vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m4_tu(merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei32_v_i32mf2_tu(vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32mf2_tu(merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei32_v_i32m1_tu(vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m1_tu(merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei32_v_i32m2_tu(vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m2_tu(merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei32_v_i32m4_tu(vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m4_tu(merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei32_v_i32m8_tu(vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m8_tu(merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei32_v_i64m1_tu(vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m1_tu(merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei32_v_i64m2_tu(vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m2_tu(merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei32_v_i64m4_tu(vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m4_tu(merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei32_v_i64m8_tu(vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m8_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32_v_u8mf8_tu(vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf8_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32_v_u8mf4_tu(vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf4_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32_v_u8mf2_tu(vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf2_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei32_v_u8m1_tu(vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m1_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei32_v_u8m2_tu(vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m2_tu(merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32_v_u16mf4_tu(vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf4_tu(merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32_v_u16mf2_tu(vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf2_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei32_v_u16m1_tu(vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m1_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei32_v_u16m2_tu(vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m2_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei32_v_u16m4_tu(vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m4_tu(merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32_v_u32mf2_tu(vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32mf2_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei32_v_u32m1_tu(vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m1_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei32_v_u32m2_tu(vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m2_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei32_v_u32m4_tu(vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m4_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei32_v_u32m8_tu(vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m8_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei32_v_u64m1_tu(vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m1_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei32_v_u64m2_tu(vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m2_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei32_v_u64m4_tu(vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m4_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei32_v_u64m8_tu(vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m8_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32_v_f32mf2_tu(vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32mf2_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32_v_f32m1_tu(vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m1_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32_v_f32m2_tu(vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m2_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32_v_f32m4_tu(vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m4_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32_v_f32m8_tu(vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m8_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32_v_f64m1_tu(vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m1_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32_v_f64m2_tu(vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m2_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32_v_f64m4_tu(vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m4_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32_v_f64m8_tu(vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m8_tu(merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_tu-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_tu-2.c
new file mode 100644
index 0000000..256e6b7
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_tu-2.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei32_v_i8mf8_tu(vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf8_tu(merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei32_v_i8mf4_tu(vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf4_tu(merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei32_v_i8mf2_tu(vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf2_tu(merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei32_v_i8m1_tu(vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m1_tu(merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei32_v_i8m2_tu(vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m2_tu(merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei32_v_i16mf4_tu(vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf4_tu(merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei32_v_i16mf2_tu(vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf2_tu(merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei32_v_i16m1_tu(vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m1_tu(merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei32_v_i16m2_tu(vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m2_tu(merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei32_v_i16m4_tu(vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m4_tu(merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei32_v_i32mf2_tu(vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32mf2_tu(merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei32_v_i32m1_tu(vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m1_tu(merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei32_v_i32m2_tu(vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m2_tu(merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei32_v_i32m4_tu(vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m4_tu(merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei32_v_i32m8_tu(vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m8_tu(merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei32_v_i64m1_tu(vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m1_tu(merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei32_v_i64m2_tu(vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m2_tu(merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei32_v_i64m4_tu(vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m4_tu(merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei32_v_i64m8_tu(vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m8_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32_v_u8mf8_tu(vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf8_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32_v_u8mf4_tu(vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf4_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32_v_u8mf2_tu(vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf2_tu(merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei32_v_u8m1_tu(vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m1_tu(merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei32_v_u8m2_tu(vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m2_tu(merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32_v_u16mf4_tu(vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf4_tu(merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32_v_u16mf2_tu(vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf2_tu(merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei32_v_u16m1_tu(vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m1_tu(merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei32_v_u16m2_tu(vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m2_tu(merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei32_v_u16m4_tu(vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m4_tu(merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32_v_u32mf2_tu(vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32mf2_tu(merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei32_v_u32m1_tu(vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m1_tu(merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei32_v_u32m2_tu(vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m2_tu(merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei32_v_u32m4_tu(vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m4_tu(merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei32_v_u32m8_tu(vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m8_tu(merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei32_v_u64m1_tu(vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m1_tu(merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei32_v_u64m2_tu(vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m2_tu(merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei32_v_u64m4_tu(vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m4_tu(merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei32_v_u64m8_tu(vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m8_tu(merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32_v_f32mf2_tu(vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32mf2_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32_v_f32m1_tu(vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m1_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32_v_f32m2_tu(vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m2_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32_v_f32m4_tu(vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m4_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32_v_f32m8_tu(vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m8_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32_v_f64m1_tu(vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m1_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32_v_f64m2_tu(vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m2_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32_v_f64m4_tu(vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m4_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32_v_f64m8_tu(vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m8_tu(merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_tu-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_tu-3.c
new file mode 100644
index 0000000..0e7c351
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_tu-3.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei32_v_i8mf8_tu(vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf8_tu(merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei32_v_i8mf4_tu(vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf4_tu(merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei32_v_i8mf2_tu(vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf2_tu(merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei32_v_i8m1_tu(vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m1_tu(merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei32_v_i8m2_tu(vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m2_tu(merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei32_v_i16mf4_tu(vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf4_tu(merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei32_v_i16mf2_tu(vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf2_tu(merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei32_v_i16m1_tu(vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m1_tu(merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei32_v_i16m2_tu(vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m2_tu(merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei32_v_i16m4_tu(vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m4_tu(merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei32_v_i32mf2_tu(vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32mf2_tu(merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei32_v_i32m1_tu(vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m1_tu(merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei32_v_i32m2_tu(vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m2_tu(merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei32_v_i32m4_tu(vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m4_tu(merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei32_v_i32m8_tu(vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m8_tu(merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei32_v_i64m1_tu(vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m1_tu(merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei32_v_i64m2_tu(vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m2_tu(merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei32_v_i64m4_tu(vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m4_tu(merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei32_v_i64m8_tu(vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m8_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32_v_u8mf8_tu(vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf8_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32_v_u8mf4_tu(vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf4_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32_v_u8mf2_tu(vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf2_tu(merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei32_v_u8m1_tu(vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m1_tu(merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei32_v_u8m2_tu(vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m2_tu(merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32_v_u16mf4_tu(vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf4_tu(merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32_v_u16mf2_tu(vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf2_tu(merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei32_v_u16m1_tu(vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m1_tu(merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei32_v_u16m2_tu(vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m2_tu(merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei32_v_u16m4_tu(vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m4_tu(merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32_v_u32mf2_tu(vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32mf2_tu(merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei32_v_u32m1_tu(vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m1_tu(merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei32_v_u32m2_tu(vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m2_tu(merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei32_v_u32m4_tu(vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m4_tu(merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei32_v_u32m8_tu(vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m8_tu(merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei32_v_u64m1_tu(vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m1_tu(merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei32_v_u64m2_tu(vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m2_tu(merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei32_v_u64m4_tu(vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m4_tu(merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei32_v_u64m8_tu(vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m8_tu(merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32_v_f32mf2_tu(vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32mf2_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32_v_f32m1_tu(vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m1_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32_v_f32m2_tu(vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m2_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32_v_f32m4_tu(vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m4_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32_v_f32m8_tu(vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m8_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32_v_f64m1_tu(vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m1_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32_v_f64m2_tu(vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m2_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32_v_f64m4_tu(vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m4_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32_v_f64m8_tu(vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m8_tu(merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_tum-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_tum-1.c
new file mode 100644
index 0000000..2f58502
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_tum-1.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei32_v_i8mf8_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei32_v_i8mf4_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei32_v_i8mf2_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei32_v_i8m1_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei32_v_i8m2_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei32_v_i16mf4_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei32_v_i16mf2_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei32_v_i16m1_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei32_v_i16m2_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei32_v_i16m4_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei32_v_i32mf2_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei32_v_i32m1_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei32_v_i32m2_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei32_v_i32m4_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei32_v_i32m8_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei32_v_i64m1_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei32_v_i64m2_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei32_v_i64m4_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei32_v_i64m8_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32_v_u8mf8_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32_v_u8mf4_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32_v_u8mf2_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei32_v_u8m1_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei32_v_u8m2_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32_v_u16mf4_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32_v_u16mf2_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei32_v_u16m1_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei32_v_u16m2_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei32_v_u16m4_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32_v_u32mf2_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei32_v_u32m1_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei32_v_u32m2_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei32_v_u32m4_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei32_v_u32m8_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei32_v_u64m1_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei32_v_u64m2_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei32_v_u64m4_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei32_v_u64m8_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32_v_f32mf2_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32_v_f32m1_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32_v_f32m2_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32_v_f32m4_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32_v_f32m8_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32_v_f64m1_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32_v_f64m2_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32_v_f64m4_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32_v_f64m8_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_tum-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_tum-2.c
new file mode 100644
index 0000000..930a466
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_tum-2.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei32_v_i8mf8_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei32_v_i8mf4_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei32_v_i8mf2_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei32_v_i8m1_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei32_v_i8m2_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei32_v_i16mf4_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei32_v_i16mf2_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei32_v_i16m1_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei32_v_i16m2_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei32_v_i16m4_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei32_v_i32mf2_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei32_v_i32m1_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei32_v_i32m2_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei32_v_i32m4_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei32_v_i32m8_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei32_v_i64m1_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei32_v_i64m2_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei32_v_i64m4_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei32_v_i64m8_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32_v_u8mf8_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32_v_u8mf4_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32_v_u8mf2_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei32_v_u8m1_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei32_v_u8m2_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32_v_u16mf4_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32_v_u16mf2_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei32_v_u16m1_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei32_v_u16m2_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei32_v_u16m4_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32_v_u32mf2_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei32_v_u32m1_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei32_v_u32m2_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei32_v_u32m4_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei32_v_u32m8_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei32_v_u64m1_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei32_v_u64m2_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei32_v_u64m4_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei32_v_u64m8_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32_v_f32mf2_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32_v_f32m1_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32_v_f32m2_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32_v_f32m4_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32_v_f32m8_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32_v_f64m1_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32_v_f64m2_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32_v_f64m4_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32_v_f64m8_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m8_tum(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_tum-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_tum-3.c
new file mode 100644
index 0000000..5db55e1
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_tum-3.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei32_v_i8mf8_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei32_v_i8mf4_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei32_v_i8mf2_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei32_v_i8m1_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei32_v_i8m2_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei32_v_i16mf4_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei32_v_i16mf2_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei32_v_i16m1_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei32_v_i16m2_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei32_v_i16m4_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei32_v_i32mf2_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei32_v_i32m1_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei32_v_i32m2_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei32_v_i32m4_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei32_v_i32m8_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei32_v_i64m1_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei32_v_i64m2_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei32_v_i64m4_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei32_v_i64m8_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32_v_u8mf8_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32_v_u8mf4_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32_v_u8mf2_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei32_v_u8m1_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei32_v_u8m2_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32_v_u16mf4_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32_v_u16mf2_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei32_v_u16m1_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei32_v_u16m2_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei32_v_u16m4_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32_v_u32mf2_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei32_v_u32m1_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei32_v_u32m2_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei32_v_u32m4_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei32_v_u32m8_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei32_v_u64m1_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei32_v_u64m2_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei32_v_u64m4_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei32_v_u64m8_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32_v_f32mf2_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32_v_f32m1_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32_v_f32m2_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32_v_f32m4_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32_v_f32m8_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32_v_f64m1_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32_v_f64m2_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32_v_f64m4_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32_v_f64m8_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m8_tum(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_tumu-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_tumu-1.c
new file mode 100644
index 0000000..111b48b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_tumu-1.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei32_v_i8mf8_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei32_v_i8mf4_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei32_v_i8mf2_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei32_v_i8m1_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei32_v_i8m2_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei32_v_i16mf4_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei32_v_i16mf2_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei32_v_i16m1_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei32_v_i16m2_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei32_v_i16m4_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei32_v_i32mf2_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei32_v_i32m1_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei32_v_i32m2_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei32_v_i32m4_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei32_v_i32m8_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei32_v_i64m1_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei32_v_i64m2_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei32_v_i64m4_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei32_v_i64m8_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32_v_u8mf8_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32_v_u8mf4_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32_v_u8mf2_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei32_v_u8m1_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei32_v_u8m2_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32_v_u16mf4_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32_v_u16mf2_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei32_v_u16m1_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei32_v_u16m2_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei32_v_u16m4_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32_v_u32mf2_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei32_v_u32m1_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei32_v_u32m2_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei32_v_u32m4_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei32_v_u32m8_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei32_v_u64m1_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei32_v_u64m2_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei32_v_u64m4_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei32_v_u64m8_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32_v_f32mf2_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32_v_f32m1_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32_v_f32m2_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32_v_f32m4_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32_v_f32m8_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32_v_f64m1_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32_v_f64m2_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32_v_f64m4_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32_v_f64m8_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_tumu-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_tumu-2.c
new file mode 100644
index 0000000..cbe677a
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_tumu-2.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei32_v_i8mf8_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei32_v_i8mf4_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei32_v_i8mf2_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei32_v_i8m1_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei32_v_i8m2_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei32_v_i16mf4_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei32_v_i16mf2_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei32_v_i16m1_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei32_v_i16m2_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei32_v_i16m4_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei32_v_i32mf2_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei32_v_i32m1_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei32_v_i32m2_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei32_v_i32m4_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei32_v_i32m8_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei32_v_i64m1_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei32_v_i64m2_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei32_v_i64m4_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei32_v_i64m8_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32_v_u8mf8_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32_v_u8mf4_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32_v_u8mf2_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei32_v_u8m1_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei32_v_u8m2_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32_v_u16mf4_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32_v_u16mf2_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei32_v_u16m1_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei32_v_u16m2_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei32_v_u16m4_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32_v_u32mf2_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei32_v_u32m1_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei32_v_u32m2_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei32_v_u32m4_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei32_v_u32m8_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei32_v_u64m1_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei32_v_u64m2_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei32_v_u64m4_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei32_v_u64m8_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32_v_f32mf2_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32_v_f32m1_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32_v_f32m2_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32_v_f32m4_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32_v_f32m8_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32_v_f64m1_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32_v_f64m2_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32_v_f64m4_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32_v_f64m8_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_tumu-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_tumu-3.c
new file mode 100644
index 0000000..7591b44
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei32_v_tumu-3.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei32_v_i8mf8_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei32_v_i8mf4_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei32_v_i8mf2_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei32_v_i8m1_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei32_v_i8m2_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i8m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei32_v_i16mf4_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei32_v_i16mf2_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei32_v_i16m1_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei32_v_i16m2_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei32_v_i16m4_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i16m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei32_v_i32mf2_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei32_v_i32m1_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei32_v_i32m2_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei32_v_i32m4_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei32_v_i32m8_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i32m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei32_v_i64m1_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei32_v_i64m2_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei32_v_i64m4_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei32_v_i64m8_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_i64m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei32_v_u8mf8_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei32_v_u8mf4_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei32_v_u8mf2_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei32_v_u8m1_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei32_v_u8m2_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u8m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei32_v_u16mf4_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei32_v_u16mf2_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei32_v_u16m1_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei32_v_u16m2_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei32_v_u16m4_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u16m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei32_v_u32mf2_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei32_v_u32m1_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei32_v_u32m2_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei32_v_u32m4_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei32_v_u32m8_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u32m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei32_v_u64m1_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei32_v_u64m2_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei32_v_u64m4_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei32_v_u64m8_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_u64m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei32_v_f32mf2_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei32_v_f32m1_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei32_v_f32m2_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei32_v_f32m4_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei32_v_f32m8_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f32m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei32_v_f64m1_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei32_v_f64m2_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei32_v_f64m4_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei32_v_f64m8_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei32_v_f64m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vloxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v-1.c
new file mode 100644
index 0000000..4f3e344
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v-1.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei64_v_i8mf8(const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf8(base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei64_v_i8mf4(const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf4(base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei64_v_i8mf2(const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf2(base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei64_v_i8m1(const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8m1(base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei64_v_i16mf4(const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf4(base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei64_v_i16mf2(const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf2(base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei64_v_i16m1(const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m1(base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei64_v_i16m2(const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m2(base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei64_v_i32mf2(const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32mf2(base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei64_v_i32m1(const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m1(base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei64_v_i32m2(const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m2(base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei64_v_i32m4(const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m4(base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei64_v_i64m1(const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m1(base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei64_v_i64m2(const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m2(base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei64_v_i64m4(const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m4(base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei64_v_i64m8(const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m8(base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64_v_u8mf8(const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf8(base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64_v_u8mf4(const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf4(base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64_v_u8mf2(const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf2(base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei64_v_u8m1(const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8m1(base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64_v_u16mf4(const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf4(base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64_v_u16mf2(const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf2(base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei64_v_u16m1(const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m1(base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei64_v_u16m2(const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m2(base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64_v_u32mf2(const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32mf2(base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei64_v_u32m1(const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m1(base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei64_v_u32m2(const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m2(base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei64_v_u32m4(const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m4(base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei64_v_u64m1(const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m1(base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei64_v_u64m2(const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m2(base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei64_v_u64m4(const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m4(base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei64_v_u64m8(const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m8(base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64_v_f32mf2(const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32mf2(base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64_v_f32m1(const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m1(base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64_v_f32m2(const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m2(base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64_v_f32m4(const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m4(base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64_v_f64m1(const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m1(base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64_v_f64m2(const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m2(base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64_v_f64m4(const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m4(base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64_v_f64m8(const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m8(base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v-2.c
new file mode 100644
index 0000000..631c45e
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v-2.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei64_v_i8mf8(const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf8(base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei64_v_i8mf4(const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf4(base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei64_v_i8mf2(const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf2(base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei64_v_i8m1(const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8m1(base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei64_v_i16mf4(const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf4(base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei64_v_i16mf2(const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf2(base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei64_v_i16m1(const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m1(base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei64_v_i16m2(const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m2(base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei64_v_i32mf2(const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32mf2(base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei64_v_i32m1(const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m1(base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei64_v_i32m2(const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m2(base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei64_v_i32m4(const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m4(base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei64_v_i64m1(const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m1(base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei64_v_i64m2(const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m2(base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei64_v_i64m4(const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m4(base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei64_v_i64m8(const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m8(base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64_v_u8mf8(const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf8(base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64_v_u8mf4(const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf4(base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64_v_u8mf2(const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf2(base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei64_v_u8m1(const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8m1(base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64_v_u16mf4(const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf4(base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64_v_u16mf2(const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf2(base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei64_v_u16m1(const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m1(base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei64_v_u16m2(const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m2(base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64_v_u32mf2(const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32mf2(base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei64_v_u32m1(const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m1(base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei64_v_u32m2(const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m2(base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei64_v_u32m4(const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m4(base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei64_v_u64m1(const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m1(base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei64_v_u64m2(const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m2(base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei64_v_u64m4(const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m4(base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei64_v_u64m8(const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m8(base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64_v_f32mf2(const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32mf2(base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64_v_f32m1(const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m1(base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64_v_f32m2(const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m2(base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64_v_f32m4(const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m4(base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64_v_f64m1(const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m1(base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64_v_f64m2(const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m2(base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64_v_f64m4(const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m4(base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64_v_f64m8(const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m8(base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v-3.c
new file mode 100644
index 0000000..5e29a64
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v-3.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei64_v_i8mf8(const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf8(base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei64_v_i8mf4(const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf4(base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei64_v_i8mf2(const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf2(base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei64_v_i8m1(const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8m1(base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei64_v_i16mf4(const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf4(base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei64_v_i16mf2(const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf2(base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei64_v_i16m1(const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m1(base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei64_v_i16m2(const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m2(base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei64_v_i32mf2(const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32mf2(base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei64_v_i32m1(const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m1(base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei64_v_i32m2(const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m2(base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei64_v_i32m4(const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m4(base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei64_v_i64m1(const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m1(base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei64_v_i64m2(const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m2(base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei64_v_i64m4(const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m4(base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei64_v_i64m8(const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m8(base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64_v_u8mf8(const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf8(base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64_v_u8mf4(const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf4(base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64_v_u8mf2(const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf2(base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei64_v_u8m1(const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8m1(base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64_v_u16mf4(const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf4(base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64_v_u16mf2(const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf2(base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei64_v_u16m1(const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m1(base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei64_v_u16m2(const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m2(base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64_v_u32mf2(const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32mf2(base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei64_v_u32m1(const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m1(base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei64_v_u32m2(const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m2(base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei64_v_u32m4(const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m4(base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei64_v_u64m1(const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m1(base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei64_v_u64m2(const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m2(base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei64_v_u64m4(const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m4(base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei64_v_u64m8(const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m8(base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64_v_f32mf2(const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32mf2(base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64_v_f32m1(const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m1(base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64_v_f32m2(const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m2(base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64_v_f32m4(const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m4(base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64_v_f64m1(const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m1(base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64_v_f64m2(const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m2(base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64_v_f64m4(const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m4(base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64_v_f64m8(const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m8(base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_m-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_m-1.c
new file mode 100644
index 0000000..0bd12a4
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_m-1.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei64_v_i8mf8_m(vbool64_t mask,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf8_m(mask,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei64_v_i8mf4_m(vbool32_t mask,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf4_m(mask,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei64_v_i8mf2_m(vbool16_t mask,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf2_m(mask,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei64_v_i8m1_m(vbool8_t mask,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8m1_m(mask,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei64_v_i16mf4_m(vbool64_t mask,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf4_m(mask,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei64_v_i16mf2_m(vbool32_t mask,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf2_m(mask,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei64_v_i16m1_m(vbool16_t mask,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m1_m(mask,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei64_v_i16m2_m(vbool8_t mask,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m2_m(mask,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei64_v_i32mf2_m(vbool64_t mask,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32mf2_m(mask,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei64_v_i32m1_m(vbool32_t mask,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m1_m(mask,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei64_v_i32m2_m(vbool16_t mask,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m2_m(mask,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei64_v_i32m4_m(vbool8_t mask,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m4_m(mask,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei64_v_i64m1_m(vbool64_t mask,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m1_m(mask,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei64_v_i64m2_m(vbool32_t mask,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m2_m(mask,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei64_v_i64m4_m(vbool16_t mask,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m4_m(mask,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei64_v_i64m8_m(vbool8_t mask,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m8_m(mask,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64_v_u8mf8_m(vbool64_t mask,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf8_m(mask,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64_v_u8mf4_m(vbool32_t mask,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf4_m(mask,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64_v_u8mf2_m(vbool16_t mask,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf2_m(mask,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei64_v_u8m1_m(vbool8_t mask,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8m1_m(mask,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64_v_u16mf4_m(vbool64_t mask,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf4_m(mask,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64_v_u16mf2_m(vbool32_t mask,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf2_m(mask,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei64_v_u16m1_m(vbool16_t mask,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m1_m(mask,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei64_v_u16m2_m(vbool8_t mask,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m2_m(mask,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64_v_u32mf2_m(vbool64_t mask,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32mf2_m(mask,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei64_v_u32m1_m(vbool32_t mask,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m1_m(mask,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei64_v_u32m2_m(vbool16_t mask,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m2_m(mask,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei64_v_u32m4_m(vbool8_t mask,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m4_m(mask,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei64_v_u64m1_m(vbool64_t mask,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m1_m(mask,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei64_v_u64m2_m(vbool32_t mask,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m2_m(mask,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei64_v_u64m4_m(vbool16_t mask,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m4_m(mask,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei64_v_u64m8_m(vbool8_t mask,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m8_m(mask,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64_v_f32mf2_m(vbool64_t mask,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32mf2_m(mask,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64_v_f32m1_m(vbool32_t mask,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m1_m(mask,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64_v_f32m2_m(vbool16_t mask,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m2_m(mask,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64_v_f32m4_m(vbool8_t mask,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m4_m(mask,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64_v_f64m1_m(vbool64_t mask,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m1_m(mask,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64_v_f64m2_m(vbool32_t mask,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m2_m(mask,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64_v_f64m4_m(vbool16_t mask,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m4_m(mask,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64_v_f64m8_m(vbool8_t mask,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m8_m(mask,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_m-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_m-2.c
new file mode 100644
index 0000000..473b8ad
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_m-2.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei64_v_i8mf8_m(vbool64_t mask,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf8_m(mask,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei64_v_i8mf4_m(vbool32_t mask,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf4_m(mask,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei64_v_i8mf2_m(vbool16_t mask,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf2_m(mask,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei64_v_i8m1_m(vbool8_t mask,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8m1_m(mask,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei64_v_i16mf4_m(vbool64_t mask,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf4_m(mask,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei64_v_i16mf2_m(vbool32_t mask,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf2_m(mask,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei64_v_i16m1_m(vbool16_t mask,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m1_m(mask,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei64_v_i16m2_m(vbool8_t mask,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m2_m(mask,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei64_v_i32mf2_m(vbool64_t mask,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32mf2_m(mask,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei64_v_i32m1_m(vbool32_t mask,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m1_m(mask,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei64_v_i32m2_m(vbool16_t mask,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m2_m(mask,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei64_v_i32m4_m(vbool8_t mask,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m4_m(mask,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei64_v_i64m1_m(vbool64_t mask,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m1_m(mask,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei64_v_i64m2_m(vbool32_t mask,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m2_m(mask,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei64_v_i64m4_m(vbool16_t mask,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m4_m(mask,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei64_v_i64m8_m(vbool8_t mask,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m8_m(mask,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64_v_u8mf8_m(vbool64_t mask,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf8_m(mask,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64_v_u8mf4_m(vbool32_t mask,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf4_m(mask,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64_v_u8mf2_m(vbool16_t mask,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf2_m(mask,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei64_v_u8m1_m(vbool8_t mask,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8m1_m(mask,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64_v_u16mf4_m(vbool64_t mask,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf4_m(mask,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64_v_u16mf2_m(vbool32_t mask,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf2_m(mask,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei64_v_u16m1_m(vbool16_t mask,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m1_m(mask,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei64_v_u16m2_m(vbool8_t mask,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m2_m(mask,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64_v_u32mf2_m(vbool64_t mask,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32mf2_m(mask,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei64_v_u32m1_m(vbool32_t mask,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m1_m(mask,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei64_v_u32m2_m(vbool16_t mask,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m2_m(mask,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei64_v_u32m4_m(vbool8_t mask,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m4_m(mask,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei64_v_u64m1_m(vbool64_t mask,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m1_m(mask,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei64_v_u64m2_m(vbool32_t mask,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m2_m(mask,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei64_v_u64m4_m(vbool16_t mask,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m4_m(mask,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei64_v_u64m8_m(vbool8_t mask,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m8_m(mask,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64_v_f32mf2_m(vbool64_t mask,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32mf2_m(mask,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64_v_f32m1_m(vbool32_t mask,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m1_m(mask,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64_v_f32m2_m(vbool16_t mask,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m2_m(mask,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64_v_f32m4_m(vbool8_t mask,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m4_m(mask,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64_v_f64m1_m(vbool64_t mask,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m1_m(mask,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64_v_f64m2_m(vbool32_t mask,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m2_m(mask,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64_v_f64m4_m(vbool16_t mask,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m4_m(mask,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64_v_f64m8_m(vbool8_t mask,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m8_m(mask,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_m-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_m-3.c
new file mode 100644
index 0000000..13b093a
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_m-3.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei64_v_i8mf8_m(vbool64_t mask,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf8_m(mask,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei64_v_i8mf4_m(vbool32_t mask,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf4_m(mask,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei64_v_i8mf2_m(vbool16_t mask,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf2_m(mask,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei64_v_i8m1_m(vbool8_t mask,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8m1_m(mask,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei64_v_i16mf4_m(vbool64_t mask,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf4_m(mask,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei64_v_i16mf2_m(vbool32_t mask,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf2_m(mask,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei64_v_i16m1_m(vbool16_t mask,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m1_m(mask,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei64_v_i16m2_m(vbool8_t mask,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m2_m(mask,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei64_v_i32mf2_m(vbool64_t mask,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32mf2_m(mask,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei64_v_i32m1_m(vbool32_t mask,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m1_m(mask,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei64_v_i32m2_m(vbool16_t mask,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m2_m(mask,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei64_v_i32m4_m(vbool8_t mask,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m4_m(mask,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei64_v_i64m1_m(vbool64_t mask,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m1_m(mask,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei64_v_i64m2_m(vbool32_t mask,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m2_m(mask,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei64_v_i64m4_m(vbool16_t mask,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m4_m(mask,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei64_v_i64m8_m(vbool8_t mask,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m8_m(mask,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64_v_u8mf8_m(vbool64_t mask,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf8_m(mask,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64_v_u8mf4_m(vbool32_t mask,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf4_m(mask,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64_v_u8mf2_m(vbool16_t mask,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf2_m(mask,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei64_v_u8m1_m(vbool8_t mask,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8m1_m(mask,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64_v_u16mf4_m(vbool64_t mask,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf4_m(mask,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64_v_u16mf2_m(vbool32_t mask,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf2_m(mask,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei64_v_u16m1_m(vbool16_t mask,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m1_m(mask,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei64_v_u16m2_m(vbool8_t mask,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m2_m(mask,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64_v_u32mf2_m(vbool64_t mask,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32mf2_m(mask,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei64_v_u32m1_m(vbool32_t mask,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m1_m(mask,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei64_v_u32m2_m(vbool16_t mask,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m2_m(mask,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei64_v_u32m4_m(vbool8_t mask,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m4_m(mask,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei64_v_u64m1_m(vbool64_t mask,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m1_m(mask,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei64_v_u64m2_m(vbool32_t mask,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m2_m(mask,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei64_v_u64m4_m(vbool16_t mask,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m4_m(mask,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei64_v_u64m8_m(vbool8_t mask,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m8_m(mask,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64_v_f32mf2_m(vbool64_t mask,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32mf2_m(mask,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64_v_f32m1_m(vbool32_t mask,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m1_m(mask,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64_v_f32m2_m(vbool16_t mask,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m2_m(mask,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64_v_f32m4_m(vbool8_t mask,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m4_m(mask,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64_v_f64m1_m(vbool64_t mask,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m1_m(mask,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64_v_f64m2_m(vbool32_t mask,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m2_m(mask,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64_v_f64m4_m(vbool16_t mask,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m4_m(mask,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64_v_f64m8_m(vbool8_t mask,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m8_m(mask,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_mu-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_mu-1.c
new file mode 100644
index 0000000..bcc6a45
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_mu-1.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei64_v_i8mf8_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei64_v_i8mf4_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei64_v_i8mf2_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei64_v_i8m1_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei64_v_i16mf4_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei64_v_i16mf2_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei64_v_i16m1_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei64_v_i16m2_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei64_v_i32mf2_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei64_v_i32m1_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei64_v_i32m2_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei64_v_i32m4_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei64_v_i64m1_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei64_v_i64m2_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei64_v_i64m4_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei64_v_i64m8_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64_v_u8mf8_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64_v_u8mf4_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64_v_u8mf2_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei64_v_u8m1_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64_v_u16mf4_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64_v_u16mf2_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei64_v_u16m1_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei64_v_u16m2_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64_v_u32mf2_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei64_v_u32m1_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei64_v_u32m2_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei64_v_u32m4_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei64_v_u64m1_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei64_v_u64m2_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei64_v_u64m4_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei64_v_u64m8_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64_v_f32mf2_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64_v_f32m1_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64_v_f32m2_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64_v_f32m4_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64_v_f64m1_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64_v_f64m2_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64_v_f64m4_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64_v_f64m8_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_mu-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_mu-2.c
new file mode 100644
index 0000000..8a60203
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_mu-2.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei64_v_i8mf8_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei64_v_i8mf4_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei64_v_i8mf2_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei64_v_i8m1_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei64_v_i16mf4_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei64_v_i16mf2_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei64_v_i16m1_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei64_v_i16m2_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei64_v_i32mf2_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei64_v_i32m1_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei64_v_i32m2_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei64_v_i32m4_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei64_v_i64m1_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei64_v_i64m2_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei64_v_i64m4_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei64_v_i64m8_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64_v_u8mf8_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64_v_u8mf4_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64_v_u8mf2_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei64_v_u8m1_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64_v_u16mf4_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64_v_u16mf2_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei64_v_u16m1_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei64_v_u16m2_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64_v_u32mf2_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei64_v_u32m1_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei64_v_u32m2_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei64_v_u32m4_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei64_v_u64m1_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei64_v_u64m2_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei64_v_u64m4_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei64_v_u64m8_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64_v_f32mf2_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64_v_f32m1_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64_v_f32m2_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64_v_f32m4_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64_v_f64m1_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64_v_f64m2_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64_v_f64m4_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64_v_f64m8_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m8_mu(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_mu-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_mu-3.c
new file mode 100644
index 0000000..cf42b3b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_mu-3.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei64_v_i8mf8_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei64_v_i8mf4_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei64_v_i8mf2_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei64_v_i8m1_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei64_v_i16mf4_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei64_v_i16mf2_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei64_v_i16m1_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei64_v_i16m2_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei64_v_i32mf2_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei64_v_i32m1_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei64_v_i32m2_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei64_v_i32m4_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei64_v_i64m1_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei64_v_i64m2_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei64_v_i64m4_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei64_v_i64m8_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64_v_u8mf8_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64_v_u8mf4_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64_v_u8mf2_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei64_v_u8m1_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64_v_u16mf4_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64_v_u16mf2_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei64_v_u16m1_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei64_v_u16m2_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64_v_u32mf2_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei64_v_u32m1_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei64_v_u32m2_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei64_v_u32m4_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei64_v_u64m1_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei64_v_u64m2_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei64_v_u64m4_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei64_v_u64m8_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64_v_f32mf2_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64_v_f32m1_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64_v_f32m2_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64_v_f32m4_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64_v_f64m1_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64_v_f64m2_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64_v_f64m4_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64_v_f64m8_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m8_mu(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_tu-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_tu-1.c
new file mode 100644
index 0000000..3ff7478
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_tu-1.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei64_v_i8mf8_tu(vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf8_tu(merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei64_v_i8mf4_tu(vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf4_tu(merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei64_v_i8mf2_tu(vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf2_tu(merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei64_v_i8m1_tu(vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8m1_tu(merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei64_v_i16mf4_tu(vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf4_tu(merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei64_v_i16mf2_tu(vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf2_tu(merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei64_v_i16m1_tu(vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m1_tu(merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei64_v_i16m2_tu(vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m2_tu(merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei64_v_i32mf2_tu(vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32mf2_tu(merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei64_v_i32m1_tu(vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m1_tu(merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei64_v_i32m2_tu(vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m2_tu(merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei64_v_i32m4_tu(vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m4_tu(merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei64_v_i64m1_tu(vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m1_tu(merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei64_v_i64m2_tu(vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m2_tu(merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei64_v_i64m4_tu(vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m4_tu(merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei64_v_i64m8_tu(vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m8_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64_v_u8mf8_tu(vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf8_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64_v_u8mf4_tu(vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf4_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64_v_u8mf2_tu(vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf2_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei64_v_u8m1_tu(vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8m1_tu(merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64_v_u16mf4_tu(vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf4_tu(merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64_v_u16mf2_tu(vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf2_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei64_v_u16m1_tu(vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m1_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei64_v_u16m2_tu(vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m2_tu(merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64_v_u32mf2_tu(vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32mf2_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei64_v_u32m1_tu(vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m1_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei64_v_u32m2_tu(vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m2_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei64_v_u32m4_tu(vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m4_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei64_v_u64m1_tu(vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m1_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei64_v_u64m2_tu(vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m2_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei64_v_u64m4_tu(vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m4_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei64_v_u64m8_tu(vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m8_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64_v_f32mf2_tu(vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32mf2_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64_v_f32m1_tu(vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m1_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64_v_f32m2_tu(vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m2_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64_v_f32m4_tu(vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m4_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64_v_f64m1_tu(vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m1_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64_v_f64m2_tu(vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m2_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64_v_f64m4_tu(vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m4_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64_v_f64m8_tu(vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m8_tu(merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_tu-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_tu-2.c
new file mode 100644
index 0000000..908bd33
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_tu-2.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei64_v_i8mf8_tu(vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf8_tu(merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei64_v_i8mf4_tu(vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf4_tu(merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei64_v_i8mf2_tu(vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf2_tu(merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei64_v_i8m1_tu(vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8m1_tu(merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei64_v_i16mf4_tu(vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf4_tu(merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei64_v_i16mf2_tu(vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf2_tu(merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei64_v_i16m1_tu(vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m1_tu(merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei64_v_i16m2_tu(vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m2_tu(merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei64_v_i32mf2_tu(vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32mf2_tu(merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei64_v_i32m1_tu(vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m1_tu(merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei64_v_i32m2_tu(vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m2_tu(merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei64_v_i32m4_tu(vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m4_tu(merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei64_v_i64m1_tu(vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m1_tu(merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei64_v_i64m2_tu(vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m2_tu(merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei64_v_i64m4_tu(vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m4_tu(merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei64_v_i64m8_tu(vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m8_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64_v_u8mf8_tu(vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf8_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64_v_u8mf4_tu(vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf4_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64_v_u8mf2_tu(vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf2_tu(merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei64_v_u8m1_tu(vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8m1_tu(merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64_v_u16mf4_tu(vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf4_tu(merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64_v_u16mf2_tu(vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf2_tu(merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei64_v_u16m1_tu(vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m1_tu(merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei64_v_u16m2_tu(vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m2_tu(merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64_v_u32mf2_tu(vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32mf2_tu(merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei64_v_u32m1_tu(vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m1_tu(merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei64_v_u32m2_tu(vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m2_tu(merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei64_v_u32m4_tu(vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m4_tu(merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei64_v_u64m1_tu(vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m1_tu(merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei64_v_u64m2_tu(vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m2_tu(merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei64_v_u64m4_tu(vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m4_tu(merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei64_v_u64m8_tu(vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m8_tu(merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64_v_f32mf2_tu(vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32mf2_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64_v_f32m1_tu(vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m1_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64_v_f32m2_tu(vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m2_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64_v_f32m4_tu(vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m4_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64_v_f64m1_tu(vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m1_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64_v_f64m2_tu(vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m2_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64_v_f64m4_tu(vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m4_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64_v_f64m8_tu(vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m8_tu(merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_tu-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_tu-3.c
new file mode 100644
index 0000000..4cf1cab
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_tu-3.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei64_v_i8mf8_tu(vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf8_tu(merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei64_v_i8mf4_tu(vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf4_tu(merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei64_v_i8mf2_tu(vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf2_tu(merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei64_v_i8m1_tu(vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8m1_tu(merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei64_v_i16mf4_tu(vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf4_tu(merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei64_v_i16mf2_tu(vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf2_tu(merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei64_v_i16m1_tu(vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m1_tu(merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei64_v_i16m2_tu(vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m2_tu(merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei64_v_i32mf2_tu(vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32mf2_tu(merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei64_v_i32m1_tu(vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m1_tu(merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei64_v_i32m2_tu(vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m2_tu(merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei64_v_i32m4_tu(vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m4_tu(merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei64_v_i64m1_tu(vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m1_tu(merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei64_v_i64m2_tu(vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m2_tu(merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei64_v_i64m4_tu(vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m4_tu(merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei64_v_i64m8_tu(vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m8_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64_v_u8mf8_tu(vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf8_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64_v_u8mf4_tu(vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf4_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64_v_u8mf2_tu(vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf2_tu(merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei64_v_u8m1_tu(vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8m1_tu(merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64_v_u16mf4_tu(vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf4_tu(merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64_v_u16mf2_tu(vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf2_tu(merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei64_v_u16m1_tu(vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m1_tu(merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei64_v_u16m2_tu(vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m2_tu(merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64_v_u32mf2_tu(vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32mf2_tu(merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei64_v_u32m1_tu(vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m1_tu(merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei64_v_u32m2_tu(vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m2_tu(merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei64_v_u32m4_tu(vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m4_tu(merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei64_v_u64m1_tu(vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m1_tu(merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei64_v_u64m2_tu(vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m2_tu(merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei64_v_u64m4_tu(vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m4_tu(merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei64_v_u64m8_tu(vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m8_tu(merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64_v_f32mf2_tu(vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32mf2_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64_v_f32m1_tu(vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m1_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64_v_f32m2_tu(vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m2_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64_v_f32m4_tu(vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m4_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64_v_f64m1_tu(vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m1_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64_v_f64m2_tu(vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m2_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64_v_f64m4_tu(vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m4_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64_v_f64m8_tu(vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m8_tu(merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_tum-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_tum-1.c
new file mode 100644
index 0000000..f512360
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_tum-1.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei64_v_i8mf8_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei64_v_i8mf4_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei64_v_i8mf2_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei64_v_i8m1_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei64_v_i16mf4_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei64_v_i16mf2_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei64_v_i16m1_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei64_v_i16m2_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei64_v_i32mf2_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei64_v_i32m1_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei64_v_i32m2_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei64_v_i32m4_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei64_v_i64m1_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei64_v_i64m2_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei64_v_i64m4_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei64_v_i64m8_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64_v_u8mf8_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64_v_u8mf4_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64_v_u8mf2_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei64_v_u8m1_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64_v_u16mf4_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64_v_u16mf2_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei64_v_u16m1_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei64_v_u16m2_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64_v_u32mf2_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei64_v_u32m1_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei64_v_u32m2_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei64_v_u32m4_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei64_v_u64m1_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei64_v_u64m2_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei64_v_u64m4_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei64_v_u64m8_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64_v_f32mf2_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64_v_f32m1_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64_v_f32m2_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64_v_f32m4_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64_v_f64m1_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64_v_f64m2_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64_v_f64m4_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64_v_f64m8_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_tum-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_tum-2.c
new file mode 100644
index 0000000..a5cdcf4
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_tum-2.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei64_v_i8mf8_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei64_v_i8mf4_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei64_v_i8mf2_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei64_v_i8m1_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei64_v_i16mf4_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei64_v_i16mf2_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei64_v_i16m1_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei64_v_i16m2_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei64_v_i32mf2_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei64_v_i32m1_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei64_v_i32m2_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei64_v_i32m4_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei64_v_i64m1_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei64_v_i64m2_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei64_v_i64m4_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei64_v_i64m8_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64_v_u8mf8_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64_v_u8mf4_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64_v_u8mf2_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei64_v_u8m1_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64_v_u16mf4_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64_v_u16mf2_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei64_v_u16m1_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei64_v_u16m2_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64_v_u32mf2_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei64_v_u32m1_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei64_v_u32m2_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei64_v_u32m4_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei64_v_u64m1_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei64_v_u64m2_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei64_v_u64m4_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei64_v_u64m8_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64_v_f32mf2_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64_v_f32m1_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64_v_f32m2_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64_v_f32m4_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64_v_f64m1_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64_v_f64m2_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64_v_f64m4_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64_v_f64m8_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m8_tum(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_tum-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_tum-3.c
new file mode 100644
index 0000000..c3ffcc9
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_tum-3.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei64_v_i8mf8_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei64_v_i8mf4_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei64_v_i8mf2_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei64_v_i8m1_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei64_v_i16mf4_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei64_v_i16mf2_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei64_v_i16m1_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei64_v_i16m2_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei64_v_i32mf2_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei64_v_i32m1_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei64_v_i32m2_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei64_v_i32m4_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei64_v_i64m1_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei64_v_i64m2_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei64_v_i64m4_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei64_v_i64m8_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64_v_u8mf8_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64_v_u8mf4_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64_v_u8mf2_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei64_v_u8m1_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64_v_u16mf4_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64_v_u16mf2_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei64_v_u16m1_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei64_v_u16m2_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64_v_u32mf2_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei64_v_u32m1_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei64_v_u32m2_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei64_v_u32m4_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei64_v_u64m1_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei64_v_u64m2_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei64_v_u64m4_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei64_v_u64m8_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64_v_f32mf2_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64_v_f32m1_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64_v_f32m2_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64_v_f32m4_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64_v_f64m1_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64_v_f64m2_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64_v_f64m4_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64_v_f64m8_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m8_tum(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_tumu-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_tumu-1.c
new file mode 100644
index 0000000..6e90964
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_tumu-1.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei64_v_i8mf8_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei64_v_i8mf4_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei64_v_i8mf2_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei64_v_i8m1_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei64_v_i16mf4_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei64_v_i16mf2_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei64_v_i16m1_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei64_v_i16m2_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei64_v_i32mf2_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei64_v_i32m1_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei64_v_i32m2_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei64_v_i32m4_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei64_v_i64m1_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei64_v_i64m2_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei64_v_i64m4_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei64_v_i64m8_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64_v_u8mf8_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64_v_u8mf4_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64_v_u8mf2_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei64_v_u8m1_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64_v_u16mf4_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64_v_u16mf2_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei64_v_u16m1_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei64_v_u16m2_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64_v_u32mf2_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei64_v_u32m1_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei64_v_u32m2_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei64_v_u32m4_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei64_v_u64m1_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei64_v_u64m2_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei64_v_u64m4_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei64_v_u64m8_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64_v_f32mf2_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64_v_f32m1_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64_v_f32m2_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64_v_f32m4_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64_v_f64m1_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64_v_f64m2_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64_v_f64m4_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64_v_f64m8_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_tumu-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_tumu-2.c
new file mode 100644
index 0000000..8469d50
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_tumu-2.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei64_v_i8mf8_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei64_v_i8mf4_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei64_v_i8mf2_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei64_v_i8m1_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei64_v_i16mf4_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei64_v_i16mf2_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei64_v_i16m1_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei64_v_i16m2_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei64_v_i32mf2_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei64_v_i32m1_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei64_v_i32m2_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei64_v_i32m4_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei64_v_i64m1_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei64_v_i64m2_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei64_v_i64m4_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei64_v_i64m8_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64_v_u8mf8_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64_v_u8mf4_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64_v_u8mf2_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei64_v_u8m1_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64_v_u16mf4_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64_v_u16mf2_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei64_v_u16m1_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei64_v_u16m2_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64_v_u32mf2_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei64_v_u32m1_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei64_v_u32m2_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei64_v_u32m4_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei64_v_u64m1_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei64_v_u64m2_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei64_v_u64m4_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei64_v_u64m8_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64_v_f32mf2_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64_v_f32m1_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64_v_f32m2_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64_v_f32m4_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64_v_f64m1_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64_v_f64m2_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64_v_f64m4_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64_v_f64m8_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_tumu-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_tumu-3.c
new file mode 100644
index 0000000..1f92993
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei64_v_tumu-3.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei64_v_i8mf8_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei64_v_i8mf4_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei64_v_i8mf2_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei64_v_i8m1_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i8m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei64_v_i16mf4_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei64_v_i16mf2_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei64_v_i16m1_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei64_v_i16m2_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i16m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei64_v_i32mf2_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei64_v_i32m1_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei64_v_i32m2_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei64_v_i32m4_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i32m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei64_v_i64m1_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei64_v_i64m2_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei64_v_i64m4_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei64_v_i64m8_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_i64m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei64_v_u8mf8_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei64_v_u8mf4_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei64_v_u8mf2_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei64_v_u8m1_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u8m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei64_v_u16mf4_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei64_v_u16mf2_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei64_v_u16m1_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei64_v_u16m2_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u16m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei64_v_u32mf2_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei64_v_u32m1_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei64_v_u32m2_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei64_v_u32m4_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u32m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei64_v_u64m1_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei64_v_u64m2_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei64_v_u64m4_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei64_v_u64m8_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_u64m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei64_v_f32mf2_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei64_v_f32m1_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei64_v_f32m2_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei64_v_f32m4_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f32m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei64_v_f64m1_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei64_v_f64m2_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei64_v_f64m4_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei64_v_f64m8_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei64_v_f64m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vloxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v-1.c
new file mode 100644
index 0000000..098475c
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v-1.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei8_v_i8mf8(const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf8(base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei8_v_i8mf4(const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf4(base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei8_v_i8mf2(const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf2(base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei8_v_i8m1(const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m1(base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei8_v_i8m2(const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m2(base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vloxei8_v_i8m4(const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m4(base,bindex,vl);
+}
+
+
+vint8m8_t test___riscv_vloxei8_v_i8m8(const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m8(base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei8_v_i16mf4(const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf4(base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei8_v_i16mf2(const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf2(base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei8_v_i16m1(const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m1(base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei8_v_i16m2(const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m2(base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei8_v_i16m4(const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m4(base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vloxei8_v_i16m8(const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m8(base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei8_v_i32mf2(const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32mf2(base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei8_v_i32m1(const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m1(base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei8_v_i32m2(const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m2(base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei8_v_i32m4(const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m4(base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei8_v_i32m8(const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m8(base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei8_v_i64m1(const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m1(base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei8_v_i64m2(const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m2(base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei8_v_i64m4(const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m4(base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei8_v_i64m8(const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m8(base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8_v_u8mf8(const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf8(base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8_v_u8mf4(const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf4(base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8_v_u8mf2(const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf2(base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei8_v_u8m1(const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m1(base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei8_v_u8m2(const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m2(base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vloxei8_v_u8m4(const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m4(base,bindex,vl);
+}
+
+
+vuint8m8_t test___riscv_vloxei8_v_u8m8(const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m8(base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8_v_u16mf4(const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf4(base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8_v_u16mf2(const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf2(base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei8_v_u16m1(const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m1(base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei8_v_u16m2(const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m2(base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei8_v_u16m4(const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m4(base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vloxei8_v_u16m8(const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m8(base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8_v_u32mf2(const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32mf2(base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei8_v_u32m1(const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m1(base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei8_v_u32m2(const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m2(base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei8_v_u32m4(const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m4(base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei8_v_u32m8(const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m8(base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei8_v_u64m1(const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m1(base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei8_v_u64m2(const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m2(base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei8_v_u64m4(const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m4(base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei8_v_u64m8(const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m8(base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8_v_f32mf2(const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32mf2(base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8_v_f32m1(const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m1(base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8_v_f32m2(const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m2(base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8_v_f32m4(const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m4(base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8_v_f32m8(const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m8(base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8_v_f64m1(const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m1(base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8_v_f64m2(const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m2(base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8_v_f64m4(const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m4(base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8_v_f64m8(const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m8(base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v-2.c
new file mode 100644
index 0000000..d236bad
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v-2.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei8_v_i8mf8(const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf8(base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei8_v_i8mf4(const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf4(base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei8_v_i8mf2(const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf2(base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei8_v_i8m1(const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m1(base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei8_v_i8m2(const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m2(base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vloxei8_v_i8m4(const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m4(base,bindex,31);
+}
+
+
+vint8m8_t test___riscv_vloxei8_v_i8m8(const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m8(base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei8_v_i16mf4(const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf4(base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei8_v_i16mf2(const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf2(base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei8_v_i16m1(const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m1(base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei8_v_i16m2(const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m2(base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei8_v_i16m4(const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m4(base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vloxei8_v_i16m8(const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m8(base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei8_v_i32mf2(const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32mf2(base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei8_v_i32m1(const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m1(base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei8_v_i32m2(const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m2(base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei8_v_i32m4(const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m4(base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei8_v_i32m8(const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m8(base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei8_v_i64m1(const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m1(base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei8_v_i64m2(const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m2(base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei8_v_i64m4(const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m4(base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei8_v_i64m8(const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m8(base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8_v_u8mf8(const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf8(base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8_v_u8mf4(const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf4(base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8_v_u8mf2(const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf2(base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei8_v_u8m1(const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m1(base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei8_v_u8m2(const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m2(base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vloxei8_v_u8m4(const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m4(base,bindex,31);
+}
+
+
+vuint8m8_t test___riscv_vloxei8_v_u8m8(const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m8(base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8_v_u16mf4(const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf4(base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8_v_u16mf2(const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf2(base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei8_v_u16m1(const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m1(base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei8_v_u16m2(const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m2(base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei8_v_u16m4(const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m4(base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vloxei8_v_u16m8(const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m8(base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8_v_u32mf2(const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32mf2(base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei8_v_u32m1(const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m1(base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei8_v_u32m2(const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m2(base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei8_v_u32m4(const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m4(base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei8_v_u32m8(const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m8(base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei8_v_u64m1(const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m1(base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei8_v_u64m2(const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m2(base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei8_v_u64m4(const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m4(base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei8_v_u64m8(const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m8(base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8_v_f32mf2(const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32mf2(base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8_v_f32m1(const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m1(base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8_v_f32m2(const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m2(base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8_v_f32m4(const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m4(base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8_v_f32m8(const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m8(base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8_v_f64m1(const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m1(base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8_v_f64m2(const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m2(base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8_v_f64m4(const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m4(base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8_v_f64m8(const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m8(base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v-3.c
new file mode 100644
index 0000000..678337f
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v-3.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei8_v_i8mf8(const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf8(base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei8_v_i8mf4(const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf4(base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei8_v_i8mf2(const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf2(base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei8_v_i8m1(const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m1(base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei8_v_i8m2(const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m2(base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vloxei8_v_i8m4(const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m4(base,bindex,32);
+}
+
+
+vint8m8_t test___riscv_vloxei8_v_i8m8(const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m8(base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei8_v_i16mf4(const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf4(base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei8_v_i16mf2(const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf2(base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei8_v_i16m1(const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m1(base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei8_v_i16m2(const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m2(base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei8_v_i16m4(const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m4(base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vloxei8_v_i16m8(const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m8(base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei8_v_i32mf2(const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32mf2(base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei8_v_i32m1(const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m1(base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei8_v_i32m2(const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m2(base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei8_v_i32m4(const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m4(base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei8_v_i32m8(const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m8(base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei8_v_i64m1(const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m1(base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei8_v_i64m2(const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m2(base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei8_v_i64m4(const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m4(base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei8_v_i64m8(const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m8(base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8_v_u8mf8(const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf8(base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8_v_u8mf4(const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf4(base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8_v_u8mf2(const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf2(base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei8_v_u8m1(const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m1(base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei8_v_u8m2(const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m2(base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vloxei8_v_u8m4(const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m4(base,bindex,32);
+}
+
+
+vuint8m8_t test___riscv_vloxei8_v_u8m8(const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m8(base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8_v_u16mf4(const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf4(base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8_v_u16mf2(const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf2(base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei8_v_u16m1(const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m1(base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei8_v_u16m2(const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m2(base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei8_v_u16m4(const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m4(base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vloxei8_v_u16m8(const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m8(base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8_v_u32mf2(const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32mf2(base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei8_v_u32m1(const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m1(base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei8_v_u32m2(const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m2(base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei8_v_u32m4(const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m4(base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei8_v_u32m8(const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m8(base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei8_v_u64m1(const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m1(base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei8_v_u64m2(const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m2(base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei8_v_u64m4(const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m4(base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei8_v_u64m8(const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m8(base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8_v_f32mf2(const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32mf2(base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8_v_f32m1(const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m1(base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8_v_f32m2(const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m2(base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8_v_f32m4(const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m4(base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8_v_f32m8(const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m8(base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8_v_f64m1(const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m1(base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8_v_f64m2(const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m2(base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8_v_f64m4(const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m4(base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8_v_f64m8(const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m8(base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_m-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_m-1.c
new file mode 100644
index 0000000..167a281
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_m-1.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei8_v_i8mf8_m(vbool64_t mask,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf8_m(mask,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei8_v_i8mf4_m(vbool32_t mask,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf4_m(mask,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei8_v_i8mf2_m(vbool16_t mask,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf2_m(mask,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei8_v_i8m1_m(vbool8_t mask,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m1_m(mask,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei8_v_i8m2_m(vbool4_t mask,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m2_m(mask,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vloxei8_v_i8m4_m(vbool2_t mask,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m4_m(mask,base,bindex,vl);
+}
+
+
+vint8m8_t test___riscv_vloxei8_v_i8m8_m(vbool1_t mask,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m8_m(mask,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei8_v_i16mf4_m(vbool64_t mask,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf4_m(mask,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei8_v_i16mf2_m(vbool32_t mask,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf2_m(mask,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei8_v_i16m1_m(vbool16_t mask,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m1_m(mask,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei8_v_i16m2_m(vbool8_t mask,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m2_m(mask,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei8_v_i16m4_m(vbool4_t mask,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m4_m(mask,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vloxei8_v_i16m8_m(vbool2_t mask,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m8_m(mask,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei8_v_i32mf2_m(vbool64_t mask,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32mf2_m(mask,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei8_v_i32m1_m(vbool32_t mask,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m1_m(mask,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei8_v_i32m2_m(vbool16_t mask,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m2_m(mask,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei8_v_i32m4_m(vbool8_t mask,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m4_m(mask,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei8_v_i32m8_m(vbool4_t mask,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m8_m(mask,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei8_v_i64m1_m(vbool64_t mask,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m1_m(mask,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei8_v_i64m2_m(vbool32_t mask,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m2_m(mask,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei8_v_i64m4_m(vbool16_t mask,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m4_m(mask,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei8_v_i64m8_m(vbool8_t mask,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m8_m(mask,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8_v_u8mf8_m(vbool64_t mask,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf8_m(mask,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8_v_u8mf4_m(vbool32_t mask,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf4_m(mask,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8_v_u8mf2_m(vbool16_t mask,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf2_m(mask,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei8_v_u8m1_m(vbool8_t mask,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m1_m(mask,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei8_v_u8m2_m(vbool4_t mask,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m2_m(mask,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vloxei8_v_u8m4_m(vbool2_t mask,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m4_m(mask,base,bindex,vl);
+}
+
+
+vuint8m8_t test___riscv_vloxei8_v_u8m8_m(vbool1_t mask,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m8_m(mask,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8_v_u16mf4_m(vbool64_t mask,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf4_m(mask,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8_v_u16mf2_m(vbool32_t mask,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf2_m(mask,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei8_v_u16m1_m(vbool16_t mask,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m1_m(mask,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei8_v_u16m2_m(vbool8_t mask,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m2_m(mask,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei8_v_u16m4_m(vbool4_t mask,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m4_m(mask,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vloxei8_v_u16m8_m(vbool2_t mask,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m8_m(mask,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8_v_u32mf2_m(vbool64_t mask,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32mf2_m(mask,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei8_v_u32m1_m(vbool32_t mask,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m1_m(mask,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei8_v_u32m2_m(vbool16_t mask,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m2_m(mask,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei8_v_u32m4_m(vbool8_t mask,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m4_m(mask,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei8_v_u32m8_m(vbool4_t mask,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m8_m(mask,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei8_v_u64m1_m(vbool64_t mask,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m1_m(mask,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei8_v_u64m2_m(vbool32_t mask,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m2_m(mask,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei8_v_u64m4_m(vbool16_t mask,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m4_m(mask,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei8_v_u64m8_m(vbool8_t mask,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m8_m(mask,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8_v_f32mf2_m(vbool64_t mask,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32mf2_m(mask,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8_v_f32m1_m(vbool32_t mask,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m1_m(mask,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8_v_f32m2_m(vbool16_t mask,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m2_m(mask,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8_v_f32m4_m(vbool8_t mask,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m4_m(mask,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8_v_f32m8_m(vbool4_t mask,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m8_m(mask,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8_v_f64m1_m(vbool64_t mask,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m1_m(mask,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8_v_f64m2_m(vbool32_t mask,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m2_m(mask,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8_v_f64m4_m(vbool16_t mask,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m4_m(mask,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8_v_f64m8_m(vbool8_t mask,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m8_m(mask,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_m-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_m-2.c
new file mode 100644
index 0000000..c3ee8df
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_m-2.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei8_v_i8mf8_m(vbool64_t mask,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf8_m(mask,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei8_v_i8mf4_m(vbool32_t mask,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf4_m(mask,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei8_v_i8mf2_m(vbool16_t mask,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf2_m(mask,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei8_v_i8m1_m(vbool8_t mask,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m1_m(mask,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei8_v_i8m2_m(vbool4_t mask,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m2_m(mask,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vloxei8_v_i8m4_m(vbool2_t mask,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m4_m(mask,base,bindex,31);
+}
+
+
+vint8m8_t test___riscv_vloxei8_v_i8m8_m(vbool1_t mask,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m8_m(mask,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei8_v_i16mf4_m(vbool64_t mask,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf4_m(mask,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei8_v_i16mf2_m(vbool32_t mask,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf2_m(mask,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei8_v_i16m1_m(vbool16_t mask,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m1_m(mask,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei8_v_i16m2_m(vbool8_t mask,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m2_m(mask,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei8_v_i16m4_m(vbool4_t mask,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m4_m(mask,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vloxei8_v_i16m8_m(vbool2_t mask,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m8_m(mask,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei8_v_i32mf2_m(vbool64_t mask,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32mf2_m(mask,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei8_v_i32m1_m(vbool32_t mask,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m1_m(mask,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei8_v_i32m2_m(vbool16_t mask,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m2_m(mask,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei8_v_i32m4_m(vbool8_t mask,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m4_m(mask,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei8_v_i32m8_m(vbool4_t mask,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m8_m(mask,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei8_v_i64m1_m(vbool64_t mask,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m1_m(mask,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei8_v_i64m2_m(vbool32_t mask,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m2_m(mask,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei8_v_i64m4_m(vbool16_t mask,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m4_m(mask,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei8_v_i64m8_m(vbool8_t mask,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m8_m(mask,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8_v_u8mf8_m(vbool64_t mask,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf8_m(mask,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8_v_u8mf4_m(vbool32_t mask,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf4_m(mask,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8_v_u8mf2_m(vbool16_t mask,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf2_m(mask,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei8_v_u8m1_m(vbool8_t mask,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m1_m(mask,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei8_v_u8m2_m(vbool4_t mask,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m2_m(mask,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vloxei8_v_u8m4_m(vbool2_t mask,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m4_m(mask,base,bindex,31);
+}
+
+
+vuint8m8_t test___riscv_vloxei8_v_u8m8_m(vbool1_t mask,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m8_m(mask,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8_v_u16mf4_m(vbool64_t mask,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf4_m(mask,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8_v_u16mf2_m(vbool32_t mask,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf2_m(mask,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei8_v_u16m1_m(vbool16_t mask,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m1_m(mask,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei8_v_u16m2_m(vbool8_t mask,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m2_m(mask,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei8_v_u16m4_m(vbool4_t mask,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m4_m(mask,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vloxei8_v_u16m8_m(vbool2_t mask,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m8_m(mask,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8_v_u32mf2_m(vbool64_t mask,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32mf2_m(mask,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei8_v_u32m1_m(vbool32_t mask,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m1_m(mask,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei8_v_u32m2_m(vbool16_t mask,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m2_m(mask,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei8_v_u32m4_m(vbool8_t mask,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m4_m(mask,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei8_v_u32m8_m(vbool4_t mask,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m8_m(mask,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei8_v_u64m1_m(vbool64_t mask,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m1_m(mask,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei8_v_u64m2_m(vbool32_t mask,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m2_m(mask,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei8_v_u64m4_m(vbool16_t mask,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m4_m(mask,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei8_v_u64m8_m(vbool8_t mask,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m8_m(mask,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8_v_f32mf2_m(vbool64_t mask,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32mf2_m(mask,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8_v_f32m1_m(vbool32_t mask,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m1_m(mask,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8_v_f32m2_m(vbool16_t mask,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m2_m(mask,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8_v_f32m4_m(vbool8_t mask,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m4_m(mask,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8_v_f32m8_m(vbool4_t mask,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m8_m(mask,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8_v_f64m1_m(vbool64_t mask,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m1_m(mask,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8_v_f64m2_m(vbool32_t mask,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m2_m(mask,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8_v_f64m4_m(vbool16_t mask,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m4_m(mask,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8_v_f64m8_m(vbool8_t mask,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m8_m(mask,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_m-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_m-3.c
new file mode 100644
index 0000000..90ac621
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_m-3.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei8_v_i8mf8_m(vbool64_t mask,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf8_m(mask,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei8_v_i8mf4_m(vbool32_t mask,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf4_m(mask,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei8_v_i8mf2_m(vbool16_t mask,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf2_m(mask,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei8_v_i8m1_m(vbool8_t mask,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m1_m(mask,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei8_v_i8m2_m(vbool4_t mask,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m2_m(mask,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vloxei8_v_i8m4_m(vbool2_t mask,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m4_m(mask,base,bindex,32);
+}
+
+
+vint8m8_t test___riscv_vloxei8_v_i8m8_m(vbool1_t mask,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m8_m(mask,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei8_v_i16mf4_m(vbool64_t mask,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf4_m(mask,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei8_v_i16mf2_m(vbool32_t mask,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf2_m(mask,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei8_v_i16m1_m(vbool16_t mask,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m1_m(mask,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei8_v_i16m2_m(vbool8_t mask,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m2_m(mask,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei8_v_i16m4_m(vbool4_t mask,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m4_m(mask,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vloxei8_v_i16m8_m(vbool2_t mask,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m8_m(mask,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei8_v_i32mf2_m(vbool64_t mask,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32mf2_m(mask,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei8_v_i32m1_m(vbool32_t mask,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m1_m(mask,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei8_v_i32m2_m(vbool16_t mask,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m2_m(mask,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei8_v_i32m4_m(vbool8_t mask,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m4_m(mask,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei8_v_i32m8_m(vbool4_t mask,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m8_m(mask,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei8_v_i64m1_m(vbool64_t mask,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m1_m(mask,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei8_v_i64m2_m(vbool32_t mask,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m2_m(mask,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei8_v_i64m4_m(vbool16_t mask,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m4_m(mask,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei8_v_i64m8_m(vbool8_t mask,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m8_m(mask,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8_v_u8mf8_m(vbool64_t mask,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf8_m(mask,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8_v_u8mf4_m(vbool32_t mask,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf4_m(mask,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8_v_u8mf2_m(vbool16_t mask,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf2_m(mask,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei8_v_u8m1_m(vbool8_t mask,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m1_m(mask,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei8_v_u8m2_m(vbool4_t mask,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m2_m(mask,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vloxei8_v_u8m4_m(vbool2_t mask,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m4_m(mask,base,bindex,32);
+}
+
+
+vuint8m8_t test___riscv_vloxei8_v_u8m8_m(vbool1_t mask,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m8_m(mask,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8_v_u16mf4_m(vbool64_t mask,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf4_m(mask,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8_v_u16mf2_m(vbool32_t mask,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf2_m(mask,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei8_v_u16m1_m(vbool16_t mask,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m1_m(mask,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei8_v_u16m2_m(vbool8_t mask,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m2_m(mask,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei8_v_u16m4_m(vbool4_t mask,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m4_m(mask,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vloxei8_v_u16m8_m(vbool2_t mask,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m8_m(mask,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8_v_u32mf2_m(vbool64_t mask,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32mf2_m(mask,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei8_v_u32m1_m(vbool32_t mask,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m1_m(mask,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei8_v_u32m2_m(vbool16_t mask,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m2_m(mask,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei8_v_u32m4_m(vbool8_t mask,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m4_m(mask,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei8_v_u32m8_m(vbool4_t mask,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m8_m(mask,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei8_v_u64m1_m(vbool64_t mask,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m1_m(mask,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei8_v_u64m2_m(vbool32_t mask,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m2_m(mask,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei8_v_u64m4_m(vbool16_t mask,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m4_m(mask,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei8_v_u64m8_m(vbool8_t mask,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m8_m(mask,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8_v_f32mf2_m(vbool64_t mask,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32mf2_m(mask,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8_v_f32m1_m(vbool32_t mask,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m1_m(mask,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8_v_f32m2_m(vbool16_t mask,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m2_m(mask,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8_v_f32m4_m(vbool8_t mask,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m4_m(mask,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8_v_f32m8_m(vbool4_t mask,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m8_m(mask,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8_v_f64m1_m(vbool64_t mask,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m1_m(mask,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8_v_f64m2_m(vbool32_t mask,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m2_m(mask,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8_v_f64m4_m(vbool16_t mask,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m4_m(mask,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8_v_f64m8_m(vbool8_t mask,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m8_m(mask,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_mu-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_mu-1.c
new file mode 100644
index 0000000..8f3e2c2
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_mu-1.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei8_v_i8mf8_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei8_v_i8mf4_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei8_v_i8mf2_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei8_v_i8m1_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei8_v_i8m2_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vloxei8_v_i8m4_mu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m8_t test___riscv_vloxei8_v_i8m8_mu(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei8_v_i16mf4_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei8_v_i16mf2_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei8_v_i16m1_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei8_v_i16m2_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei8_v_i16m4_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vloxei8_v_i16m8_mu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei8_v_i32mf2_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei8_v_i32m1_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei8_v_i32m2_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei8_v_i32m4_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei8_v_i32m8_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei8_v_i64m1_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei8_v_i64m2_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei8_v_i64m4_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei8_v_i64m8_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8_v_u8mf8_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8_v_u8mf4_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8_v_u8mf2_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei8_v_u8m1_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei8_v_u8m2_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vloxei8_v_u8m4_mu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m8_t test___riscv_vloxei8_v_u8m8_mu(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8_v_u16mf4_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8_v_u16mf2_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei8_v_u16m1_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei8_v_u16m2_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei8_v_u16m4_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vloxei8_v_u16m8_mu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8_v_u32mf2_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei8_v_u32m1_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei8_v_u32m2_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei8_v_u32m4_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei8_v_u32m8_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei8_v_u64m1_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei8_v_u64m2_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei8_v_u64m4_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei8_v_u64m8_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8_v_f32mf2_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8_v_f32m1_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8_v_f32m2_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8_v_f32m4_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8_v_f32m8_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8_v_f64m1_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8_v_f64m2_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8_v_f64m4_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8_v_f64m8_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_mu-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_mu-2.c
new file mode 100644
index 0000000..d94e729
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_mu-2.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei8_v_i8mf8_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei8_v_i8mf4_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei8_v_i8mf2_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei8_v_i8m1_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei8_v_i8m2_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vloxei8_v_i8m4_mu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m8_t test___riscv_vloxei8_v_i8m8_mu(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei8_v_i16mf4_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei8_v_i16mf2_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei8_v_i16m1_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei8_v_i16m2_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei8_v_i16m4_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vloxei8_v_i16m8_mu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei8_v_i32mf2_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei8_v_i32m1_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei8_v_i32m2_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei8_v_i32m4_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei8_v_i32m8_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei8_v_i64m1_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei8_v_i64m2_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei8_v_i64m4_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei8_v_i64m8_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8_v_u8mf8_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8_v_u8mf4_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8_v_u8mf2_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei8_v_u8m1_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei8_v_u8m2_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vloxei8_v_u8m4_mu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m8_t test___riscv_vloxei8_v_u8m8_mu(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8_v_u16mf4_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8_v_u16mf2_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei8_v_u16m1_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei8_v_u16m2_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei8_v_u16m4_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vloxei8_v_u16m8_mu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8_v_u32mf2_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei8_v_u32m1_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei8_v_u32m2_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei8_v_u32m4_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei8_v_u32m8_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei8_v_u64m1_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei8_v_u64m2_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei8_v_u64m4_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei8_v_u64m8_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8_v_f32mf2_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8_v_f32m1_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8_v_f32m2_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8_v_f32m4_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8_v_f32m8_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8_v_f64m1_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8_v_f64m2_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8_v_f64m4_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8_v_f64m8_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m8_mu(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_mu-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_mu-3.c
new file mode 100644
index 0000000..1b86967
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_mu-3.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei8_v_i8mf8_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei8_v_i8mf4_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei8_v_i8mf2_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei8_v_i8m1_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei8_v_i8m2_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vloxei8_v_i8m4_mu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m8_t test___riscv_vloxei8_v_i8m8_mu(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei8_v_i16mf4_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei8_v_i16mf2_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei8_v_i16m1_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei8_v_i16m2_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei8_v_i16m4_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vloxei8_v_i16m8_mu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei8_v_i32mf2_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei8_v_i32m1_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei8_v_i32m2_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei8_v_i32m4_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei8_v_i32m8_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei8_v_i64m1_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei8_v_i64m2_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei8_v_i64m4_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei8_v_i64m8_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8_v_u8mf8_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8_v_u8mf4_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8_v_u8mf2_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei8_v_u8m1_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei8_v_u8m2_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vloxei8_v_u8m4_mu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m8_t test___riscv_vloxei8_v_u8m8_mu(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8_v_u16mf4_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8_v_u16mf2_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei8_v_u16m1_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei8_v_u16m2_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei8_v_u16m4_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vloxei8_v_u16m8_mu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8_v_u32mf2_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei8_v_u32m1_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei8_v_u32m2_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei8_v_u32m4_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei8_v_u32m8_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei8_v_u64m1_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei8_v_u64m2_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei8_v_u64m4_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei8_v_u64m8_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8_v_f32mf2_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8_v_f32m1_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8_v_f32m2_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8_v_f32m4_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8_v_f32m8_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8_v_f64m1_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8_v_f64m2_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8_v_f64m4_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8_v_f64m8_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m8_mu(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_tu-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_tu-1.c
new file mode 100644
index 0000000..9d9b544
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_tu-1.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei8_v_i8mf8_tu(vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf8_tu(merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei8_v_i8mf4_tu(vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf4_tu(merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei8_v_i8mf2_tu(vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf2_tu(merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei8_v_i8m1_tu(vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m1_tu(merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei8_v_i8m2_tu(vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m2_tu(merge,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vloxei8_v_i8m4_tu(vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m4_tu(merge,base,bindex,vl);
+}
+
+
+vint8m8_t test___riscv_vloxei8_v_i8m8_tu(vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m8_tu(merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei8_v_i16mf4_tu(vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf4_tu(merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei8_v_i16mf2_tu(vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf2_tu(merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei8_v_i16m1_tu(vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m1_tu(merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei8_v_i16m2_tu(vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m2_tu(merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei8_v_i16m4_tu(vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m4_tu(merge,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vloxei8_v_i16m8_tu(vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m8_tu(merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei8_v_i32mf2_tu(vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32mf2_tu(merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei8_v_i32m1_tu(vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m1_tu(merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei8_v_i32m2_tu(vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m2_tu(merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei8_v_i32m4_tu(vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m4_tu(merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei8_v_i32m8_tu(vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m8_tu(merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei8_v_i64m1_tu(vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m1_tu(merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei8_v_i64m2_tu(vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m2_tu(merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei8_v_i64m4_tu(vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m4_tu(merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei8_v_i64m8_tu(vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m8_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8_v_u8mf8_tu(vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf8_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8_v_u8mf4_tu(vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf4_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8_v_u8mf2_tu(vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf2_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei8_v_u8m1_tu(vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m1_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei8_v_u8m2_tu(vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m2_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vloxei8_v_u8m4_tu(vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m4_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m8_t test___riscv_vloxei8_v_u8m8_tu(vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m8_tu(merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8_v_u16mf4_tu(vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf4_tu(merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8_v_u16mf2_tu(vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf2_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei8_v_u16m1_tu(vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m1_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei8_v_u16m2_tu(vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m2_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei8_v_u16m4_tu(vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m4_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vloxei8_v_u16m8_tu(vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m8_tu(merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8_v_u32mf2_tu(vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32mf2_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei8_v_u32m1_tu(vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m1_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei8_v_u32m2_tu(vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m2_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei8_v_u32m4_tu(vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m4_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei8_v_u32m8_tu(vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m8_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei8_v_u64m1_tu(vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m1_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei8_v_u64m2_tu(vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m2_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei8_v_u64m4_tu(vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m4_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei8_v_u64m8_tu(vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m8_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8_v_f32mf2_tu(vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32mf2_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8_v_f32m1_tu(vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m1_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8_v_f32m2_tu(vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m2_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8_v_f32m4_tu(vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m4_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8_v_f32m8_tu(vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m8_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8_v_f64m1_tu(vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m1_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8_v_f64m2_tu(vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m2_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8_v_f64m4_tu(vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m4_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8_v_f64m8_tu(vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m8_tu(merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_tu-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_tu-2.c
new file mode 100644
index 0000000..820f262
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_tu-2.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei8_v_i8mf8_tu(vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf8_tu(merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei8_v_i8mf4_tu(vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf4_tu(merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei8_v_i8mf2_tu(vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf2_tu(merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei8_v_i8m1_tu(vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m1_tu(merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei8_v_i8m2_tu(vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m2_tu(merge,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vloxei8_v_i8m4_tu(vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m4_tu(merge,base,bindex,31);
+}
+
+
+vint8m8_t test___riscv_vloxei8_v_i8m8_tu(vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m8_tu(merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei8_v_i16mf4_tu(vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf4_tu(merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei8_v_i16mf2_tu(vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf2_tu(merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei8_v_i16m1_tu(vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m1_tu(merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei8_v_i16m2_tu(vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m2_tu(merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei8_v_i16m4_tu(vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m4_tu(merge,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vloxei8_v_i16m8_tu(vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m8_tu(merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei8_v_i32mf2_tu(vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32mf2_tu(merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei8_v_i32m1_tu(vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m1_tu(merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei8_v_i32m2_tu(vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m2_tu(merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei8_v_i32m4_tu(vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m4_tu(merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei8_v_i32m8_tu(vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m8_tu(merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei8_v_i64m1_tu(vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m1_tu(merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei8_v_i64m2_tu(vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m2_tu(merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei8_v_i64m4_tu(vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m4_tu(merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei8_v_i64m8_tu(vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m8_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8_v_u8mf8_tu(vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf8_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8_v_u8mf4_tu(vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf4_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8_v_u8mf2_tu(vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf2_tu(merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei8_v_u8m1_tu(vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m1_tu(merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei8_v_u8m2_tu(vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m2_tu(merge,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vloxei8_v_u8m4_tu(vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m4_tu(merge,base,bindex,31);
+}
+
+
+vuint8m8_t test___riscv_vloxei8_v_u8m8_tu(vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m8_tu(merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8_v_u16mf4_tu(vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf4_tu(merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8_v_u16mf2_tu(vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf2_tu(merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei8_v_u16m1_tu(vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m1_tu(merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei8_v_u16m2_tu(vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m2_tu(merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei8_v_u16m4_tu(vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m4_tu(merge,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vloxei8_v_u16m8_tu(vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m8_tu(merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8_v_u32mf2_tu(vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32mf2_tu(merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei8_v_u32m1_tu(vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m1_tu(merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei8_v_u32m2_tu(vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m2_tu(merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei8_v_u32m4_tu(vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m4_tu(merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei8_v_u32m8_tu(vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m8_tu(merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei8_v_u64m1_tu(vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m1_tu(merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei8_v_u64m2_tu(vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m2_tu(merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei8_v_u64m4_tu(vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m4_tu(merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei8_v_u64m8_tu(vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m8_tu(merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8_v_f32mf2_tu(vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32mf2_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8_v_f32m1_tu(vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m1_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8_v_f32m2_tu(vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m2_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8_v_f32m4_tu(vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m4_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8_v_f32m8_tu(vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m8_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8_v_f64m1_tu(vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m1_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8_v_f64m2_tu(vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m2_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8_v_f64m4_tu(vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m4_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8_v_f64m8_tu(vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m8_tu(merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_tu-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_tu-3.c
new file mode 100644
index 0000000..b47df5f
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_tu-3.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei8_v_i8mf8_tu(vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf8_tu(merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei8_v_i8mf4_tu(vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf4_tu(merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei8_v_i8mf2_tu(vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf2_tu(merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei8_v_i8m1_tu(vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m1_tu(merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei8_v_i8m2_tu(vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m2_tu(merge,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vloxei8_v_i8m4_tu(vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m4_tu(merge,base,bindex,32);
+}
+
+
+vint8m8_t test___riscv_vloxei8_v_i8m8_tu(vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m8_tu(merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei8_v_i16mf4_tu(vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf4_tu(merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei8_v_i16mf2_tu(vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf2_tu(merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei8_v_i16m1_tu(vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m1_tu(merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei8_v_i16m2_tu(vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m2_tu(merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei8_v_i16m4_tu(vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m4_tu(merge,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vloxei8_v_i16m8_tu(vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m8_tu(merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei8_v_i32mf2_tu(vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32mf2_tu(merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei8_v_i32m1_tu(vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m1_tu(merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei8_v_i32m2_tu(vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m2_tu(merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei8_v_i32m4_tu(vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m4_tu(merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei8_v_i32m8_tu(vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m8_tu(merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei8_v_i64m1_tu(vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m1_tu(merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei8_v_i64m2_tu(vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m2_tu(merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei8_v_i64m4_tu(vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m4_tu(merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei8_v_i64m8_tu(vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m8_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8_v_u8mf8_tu(vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf8_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8_v_u8mf4_tu(vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf4_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8_v_u8mf2_tu(vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf2_tu(merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei8_v_u8m1_tu(vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m1_tu(merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei8_v_u8m2_tu(vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m2_tu(merge,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vloxei8_v_u8m4_tu(vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m4_tu(merge,base,bindex,32);
+}
+
+
+vuint8m8_t test___riscv_vloxei8_v_u8m8_tu(vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m8_tu(merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8_v_u16mf4_tu(vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf4_tu(merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8_v_u16mf2_tu(vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf2_tu(merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei8_v_u16m1_tu(vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m1_tu(merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei8_v_u16m2_tu(vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m2_tu(merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei8_v_u16m4_tu(vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m4_tu(merge,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vloxei8_v_u16m8_tu(vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m8_tu(merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8_v_u32mf2_tu(vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32mf2_tu(merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei8_v_u32m1_tu(vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m1_tu(merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei8_v_u32m2_tu(vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m2_tu(merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei8_v_u32m4_tu(vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m4_tu(merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei8_v_u32m8_tu(vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m8_tu(merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei8_v_u64m1_tu(vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m1_tu(merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei8_v_u64m2_tu(vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m2_tu(merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei8_v_u64m4_tu(vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m4_tu(merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei8_v_u64m8_tu(vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m8_tu(merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8_v_f32mf2_tu(vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32mf2_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8_v_f32m1_tu(vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m1_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8_v_f32m2_tu(vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m2_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8_v_f32m4_tu(vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m4_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8_v_f32m8_tu(vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m8_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8_v_f64m1_tu(vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m1_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8_v_f64m2_tu(vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m2_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8_v_f64m4_tu(vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m4_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8_v_f64m8_tu(vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m8_tu(merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_tum-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_tum-1.c
new file mode 100644
index 0000000..72ddcce
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_tum-1.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei8_v_i8mf8_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei8_v_i8mf4_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei8_v_i8mf2_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei8_v_i8m1_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei8_v_i8m2_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vloxei8_v_i8m4_tum(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m8_t test___riscv_vloxei8_v_i8m8_tum(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei8_v_i16mf4_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei8_v_i16mf2_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei8_v_i16m1_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei8_v_i16m2_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei8_v_i16m4_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vloxei8_v_i16m8_tum(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei8_v_i32mf2_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei8_v_i32m1_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei8_v_i32m2_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei8_v_i32m4_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei8_v_i32m8_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei8_v_i64m1_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei8_v_i64m2_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei8_v_i64m4_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei8_v_i64m8_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8_v_u8mf8_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8_v_u8mf4_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8_v_u8mf2_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei8_v_u8m1_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei8_v_u8m2_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vloxei8_v_u8m4_tum(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m8_t test___riscv_vloxei8_v_u8m8_tum(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8_v_u16mf4_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8_v_u16mf2_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei8_v_u16m1_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei8_v_u16m2_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei8_v_u16m4_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vloxei8_v_u16m8_tum(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8_v_u32mf2_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei8_v_u32m1_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei8_v_u32m2_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei8_v_u32m4_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei8_v_u32m8_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei8_v_u64m1_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei8_v_u64m2_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei8_v_u64m4_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei8_v_u64m8_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8_v_f32mf2_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8_v_f32m1_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8_v_f32m2_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8_v_f32m4_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8_v_f32m8_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8_v_f64m1_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8_v_f64m2_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8_v_f64m4_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8_v_f64m8_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_tum-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_tum-2.c
new file mode 100644
index 0000000..c744db4
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_tum-2.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei8_v_i8mf8_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei8_v_i8mf4_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei8_v_i8mf2_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei8_v_i8m1_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei8_v_i8m2_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vloxei8_v_i8m4_tum(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m8_t test___riscv_vloxei8_v_i8m8_tum(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei8_v_i16mf4_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei8_v_i16mf2_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei8_v_i16m1_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei8_v_i16m2_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei8_v_i16m4_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vloxei8_v_i16m8_tum(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei8_v_i32mf2_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei8_v_i32m1_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei8_v_i32m2_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei8_v_i32m4_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei8_v_i32m8_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei8_v_i64m1_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei8_v_i64m2_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei8_v_i64m4_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei8_v_i64m8_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8_v_u8mf8_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8_v_u8mf4_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8_v_u8mf2_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei8_v_u8m1_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei8_v_u8m2_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vloxei8_v_u8m4_tum(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m8_t test___riscv_vloxei8_v_u8m8_tum(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8_v_u16mf4_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8_v_u16mf2_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei8_v_u16m1_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei8_v_u16m2_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei8_v_u16m4_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vloxei8_v_u16m8_tum(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8_v_u32mf2_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei8_v_u32m1_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei8_v_u32m2_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei8_v_u32m4_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei8_v_u32m8_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei8_v_u64m1_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei8_v_u64m2_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei8_v_u64m4_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei8_v_u64m8_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8_v_f32mf2_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8_v_f32m1_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8_v_f32m2_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8_v_f32m4_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8_v_f32m8_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8_v_f64m1_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8_v_f64m2_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8_v_f64m4_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8_v_f64m8_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m8_tum(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_tum-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_tum-3.c
new file mode 100644
index 0000000..b4b97e9
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_tum-3.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei8_v_i8mf8_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei8_v_i8mf4_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei8_v_i8mf2_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei8_v_i8m1_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei8_v_i8m2_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vloxei8_v_i8m4_tum(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m8_t test___riscv_vloxei8_v_i8m8_tum(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei8_v_i16mf4_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei8_v_i16mf2_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei8_v_i16m1_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei8_v_i16m2_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei8_v_i16m4_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vloxei8_v_i16m8_tum(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei8_v_i32mf2_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei8_v_i32m1_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei8_v_i32m2_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei8_v_i32m4_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei8_v_i32m8_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei8_v_i64m1_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei8_v_i64m2_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei8_v_i64m4_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei8_v_i64m8_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8_v_u8mf8_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8_v_u8mf4_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8_v_u8mf2_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei8_v_u8m1_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei8_v_u8m2_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vloxei8_v_u8m4_tum(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m8_t test___riscv_vloxei8_v_u8m8_tum(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8_v_u16mf4_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8_v_u16mf2_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei8_v_u16m1_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei8_v_u16m2_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei8_v_u16m4_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vloxei8_v_u16m8_tum(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8_v_u32mf2_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei8_v_u32m1_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei8_v_u32m2_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei8_v_u32m4_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei8_v_u32m8_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei8_v_u64m1_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei8_v_u64m2_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei8_v_u64m4_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei8_v_u64m8_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8_v_f32mf2_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8_v_f32m1_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8_v_f32m2_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8_v_f32m4_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8_v_f32m8_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8_v_f64m1_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8_v_f64m2_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8_v_f64m4_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8_v_f64m8_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m8_tum(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_tumu-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_tumu-1.c
new file mode 100644
index 0000000..34affa6
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_tumu-1.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei8_v_i8mf8_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vloxei8_v_i8mf4_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vloxei8_v_i8mf2_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vloxei8_v_i8m1_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vloxei8_v_i8m2_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vloxei8_v_i8m4_tumu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m8_t test___riscv_vloxei8_v_i8m8_tumu(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vloxei8_v_i16mf4_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vloxei8_v_i16mf2_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vloxei8_v_i16m1_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vloxei8_v_i16m2_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vloxei8_v_i16m4_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vloxei8_v_i16m8_tumu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vloxei8_v_i32mf2_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vloxei8_v_i32m1_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vloxei8_v_i32m2_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vloxei8_v_i32m4_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vloxei8_v_i32m8_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vloxei8_v_i64m1_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vloxei8_v_i64m2_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vloxei8_v_i64m4_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vloxei8_v_i64m8_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8_v_u8mf8_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8_v_u8mf4_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8_v_u8mf2_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vloxei8_v_u8m1_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vloxei8_v_u8m2_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vloxei8_v_u8m4_tumu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m8_t test___riscv_vloxei8_v_u8m8_tumu(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8_v_u16mf4_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8_v_u16mf2_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vloxei8_v_u16m1_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vloxei8_v_u16m2_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vloxei8_v_u16m4_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vloxei8_v_u16m8_tumu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8_v_u32mf2_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vloxei8_v_u32m1_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vloxei8_v_u32m2_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vloxei8_v_u32m4_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vloxei8_v_u32m8_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vloxei8_v_u64m1_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vloxei8_v_u64m2_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vloxei8_v_u64m4_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vloxei8_v_u64m8_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8_v_f32mf2_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8_v_f32m1_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8_v_f32m2_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8_v_f32m4_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8_v_f32m8_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8_v_f64m1_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8_v_f64m2_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8_v_f64m4_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8_v_f64m8_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_tumu-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_tumu-2.c
new file mode 100644
index 0000000..5d63696
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_tumu-2.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei8_v_i8mf8_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vloxei8_v_i8mf4_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vloxei8_v_i8mf2_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vloxei8_v_i8m1_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vloxei8_v_i8m2_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vloxei8_v_i8m4_tumu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m8_t test___riscv_vloxei8_v_i8m8_tumu(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vloxei8_v_i16mf4_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vloxei8_v_i16mf2_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vloxei8_v_i16m1_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vloxei8_v_i16m2_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vloxei8_v_i16m4_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vloxei8_v_i16m8_tumu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vloxei8_v_i32mf2_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vloxei8_v_i32m1_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vloxei8_v_i32m2_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vloxei8_v_i32m4_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vloxei8_v_i32m8_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vloxei8_v_i64m1_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vloxei8_v_i64m2_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vloxei8_v_i64m4_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vloxei8_v_i64m8_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8_v_u8mf8_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8_v_u8mf4_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8_v_u8mf2_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vloxei8_v_u8m1_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vloxei8_v_u8m2_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vloxei8_v_u8m4_tumu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m8_t test___riscv_vloxei8_v_u8m8_tumu(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8_v_u16mf4_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8_v_u16mf2_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vloxei8_v_u16m1_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vloxei8_v_u16m2_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vloxei8_v_u16m4_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vloxei8_v_u16m8_tumu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8_v_u32mf2_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vloxei8_v_u32m1_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vloxei8_v_u32m2_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vloxei8_v_u32m4_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vloxei8_v_u32m8_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vloxei8_v_u64m1_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vloxei8_v_u64m2_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vloxei8_v_u64m4_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vloxei8_v_u64m8_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8_v_f32mf2_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8_v_f32m1_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8_v_f32m2_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8_v_f32m4_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8_v_f32m8_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8_v_f64m1_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8_v_f64m2_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8_v_f64m4_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8_v_f64m8_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_tumu-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_tumu-3.c
new file mode 100644
index 0000000..ff4530b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vloxei8_v_tumu-3.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vloxei8_v_i8mf8_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vloxei8_v_i8mf4_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vloxei8_v_i8mf2_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vloxei8_v_i8m1_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vloxei8_v_i8m2_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vloxei8_v_i8m4_tumu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m8_t test___riscv_vloxei8_v_i8m8_tumu(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i8m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vloxei8_v_i16mf4_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vloxei8_v_i16mf2_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vloxei8_v_i16m1_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vloxei8_v_i16m2_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vloxei8_v_i16m4_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vloxei8_v_i16m8_tumu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i16m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vloxei8_v_i32mf2_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vloxei8_v_i32m1_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vloxei8_v_i32m2_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vloxei8_v_i32m4_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vloxei8_v_i32m8_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i32m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vloxei8_v_i64m1_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vloxei8_v_i64m2_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vloxei8_v_i64m4_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vloxei8_v_i64m8_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_i64m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vloxei8_v_u8mf8_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vloxei8_v_u8mf4_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vloxei8_v_u8mf2_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vloxei8_v_u8m1_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vloxei8_v_u8m2_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vloxei8_v_u8m4_tumu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m8_t test___riscv_vloxei8_v_u8m8_tumu(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u8m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vloxei8_v_u16mf4_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vloxei8_v_u16mf2_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vloxei8_v_u16m1_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vloxei8_v_u16m2_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vloxei8_v_u16m4_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vloxei8_v_u16m8_tumu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u16m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vloxei8_v_u32mf2_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vloxei8_v_u32m1_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vloxei8_v_u32m2_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vloxei8_v_u32m4_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vloxei8_v_u32m8_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u32m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vloxei8_v_u64m1_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vloxei8_v_u64m2_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vloxei8_v_u64m4_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vloxei8_v_u64m8_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_u64m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vloxei8_v_f32mf2_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vloxei8_v_f32m1_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vloxei8_v_f32m2_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vloxei8_v_f32m4_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vloxei8_v_f32m8_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f32m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vloxei8_v_f64m1_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vloxei8_v_f64m2_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vloxei8_v_f64m4_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vloxei8_v_f64m8_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vloxei8_v_f64m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vloxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vlse-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse-1.c
new file mode 100644
index 0000000..b7e7ef0
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse-1.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vlse8_v_i8mf8(int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf8(base,bstride,vl);
+}
+
+vint8mf4_t
+test___riscv_vlse8_v_i8mf4(int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf4(base,bstride,vl);
+}
+
+vint8mf2_t
+test___riscv_vlse8_v_i8mf2(int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf2(base,bstride,vl);
+}
+
+vint8m1_t
+test___riscv_vlse8_v_i8m1(int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m1(base,bstride,vl);
+}
+
+vint8m2_t
+test___riscv_vlse8_v_i8m2(int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m2(base,bstride,vl);
+}
+
+vint8m4_t
+test___riscv_vlse8_v_i8m4(int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m4(base,bstride,vl);
+}
+
+vint8m8_t
+test___riscv_vlse8_v_i8m8(int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m8(base,bstride,vl);
+}
+
+vuint8mf8_t
+test___riscv_vlse8_v_u8mf8(uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf8(base,bstride,vl);
+}
+
+vuint8mf4_t
+test___riscv_vlse8_v_u8mf4(uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf4(base,bstride,vl);
+}
+
+vuint8mf2_t
+test___riscv_vlse8_v_u8mf2(uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf2(base,bstride,vl);
+}
+
+vuint8m1_t
+test___riscv_vlse8_v_u8m1(uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m1(base,bstride,vl);
+}
+
+vuint8m2_t
+test___riscv_vlse8_v_u8m2(uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m2(base,bstride,vl);
+}
+
+vuint8m4_t
+test___riscv_vlse8_v_u8m4(uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m4(base,bstride,vl);
+}
+
+vuint8m8_t
+test___riscv_vlse8_v_u8m8(uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m8(base,bstride,vl);
+}
+
+vint16mf4_t
+test___riscv_vlse16_v_i16mf4(int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf4(base,bstride,vl);
+}
+
+vint16mf2_t
+test___riscv_vlse16_v_i16mf2(int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf2(base,bstride,vl);
+}
+
+vint16m1_t
+test___riscv_vlse16_v_i16m1(int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m1(base,bstride,vl);
+}
+
+vint16m2_t
+test___riscv_vlse16_v_i16m2(int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m2(base,bstride,vl);
+}
+
+vint16m4_t
+test___riscv_vlse16_v_i16m4(int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m4(base,bstride,vl);
+}
+
+vint16m8_t
+test___riscv_vlse16_v_i16m8(int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m8(base,bstride,vl);
+}
+
+vuint16mf4_t
+test___riscv_vlse16_v_u16mf4(uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf4(base,bstride,vl);
+}
+
+vuint16mf2_t
+test___riscv_vlse16_v_u16mf2(uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf2(base,bstride,vl);
+}
+
+vuint16m1_t
+test___riscv_vlse16_v_u16m1(uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m1(base,bstride,vl);
+}
+
+vuint16m2_t
+test___riscv_vlse16_v_u16m2(uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m2(base,bstride,vl);
+}
+
+vuint16m4_t
+test___riscv_vlse16_v_u16m4(uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m4(base,bstride,vl);
+}
+
+vuint16m8_t
+test___riscv_vlse16_v_u16m8(uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m8(base,bstride,vl);
+}
+
+vint32mf2_t
+test___riscv_vlse32_v_i32mf2(int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32mf2(base,bstride,vl);
+}
+
+vint32m1_t
+test___riscv_vlse32_v_i32m1(int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m1(base,bstride,vl);
+}
+
+vint32m2_t
+test___riscv_vlse32_v_i32m2(int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m2(base,bstride,vl);
+}
+
+vint32m4_t
+test___riscv_vlse32_v_i32m4(int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m4(base,bstride,vl);
+}
+
+vint32m8_t
+test___riscv_vlse32_v_i32m8(int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m8(base,bstride,vl);
+}
+
+vuint32mf2_t
+test___riscv_vlse32_v_u32mf2(uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32mf2(base,bstride,vl);
+}
+
+vuint32m1_t
+test___riscv_vlse32_v_u32m1(uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m1(base,bstride,vl);
+}
+
+vuint32m2_t
+test___riscv_vlse32_v_u32m2(uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m2(base,bstride,vl);
+}
+
+vuint32m4_t
+test___riscv_vlse32_v_u32m4(uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m4(base,bstride,vl);
+}
+
+vuint32m8_t
+test___riscv_vlse32_v_u32m8(uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m8(base,bstride,vl);
+}
+
+vfloat32mf2_t
+test___riscv_vlse32_v_f32mf2(float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32mf2(base,bstride,vl);
+}
+
+vfloat32m1_t
+test___riscv_vlse32_v_f32m1(float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m1(base,bstride,vl);
+}
+
+vfloat32m2_t
+test___riscv_vlse32_v_f32m2(float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m2(base,bstride,vl);
+}
+
+vfloat32m4_t
+test___riscv_vlse32_v_f32m4(float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m4(base,bstride,vl);
+}
+
+vfloat32m8_t
+test___riscv_vlse32_v_f32m8(float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m8(base,bstride,vl);
+}
+
+vint64m1_t
+test___riscv_vlse64_v_i64m1(int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m1(base,bstride,vl);
+}
+
+vint64m2_t
+test___riscv_vlse64_v_i64m2(int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m2(base,bstride,vl);
+}
+
+vint64m4_t
+test___riscv_vlse64_v_i64m4(int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m4(base,bstride,vl);
+}
+
+vint64m8_t
+test___riscv_vlse64_v_i64m8(int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m8(base,bstride,vl);
+}
+
+vuint64m1_t
+test___riscv_vlse64_v_u64m1(uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m1(base,bstride,vl);
+}
+
+vuint64m2_t
+test___riscv_vlse64_v_u64m2(uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m2(base,bstride,vl);
+}
+
+vuint64m4_t
+test___riscv_vlse64_v_u64m4(uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m4(base,bstride,vl);
+}
+
+vuint64m8_t
+test___riscv_vlse64_v_u64m8(uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m8(base,bstride,vl);
+}
+
+vfloat64m1_t
+test___riscv_vlse64_v_f64m1(double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m1(base,bstride,vl);
+}
+
+vfloat64m2_t
+test___riscv_vlse64_v_f64m2(double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m2(base,bstride,vl);
+}
+
+vfloat64m4_t
+test___riscv_vlse64_v_f64m4(double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m4(base,bstride,vl);
+}
+
+vfloat64m8_t
+test___riscv_vlse64_v_f64m8(double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m8(base,bstride,vl);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vlse-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse-2.c
new file mode 100644
index 0000000..221aacd
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse-2.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vlse8_v_i8mf8(int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf8(base,bstride,31);
+}
+
+vint8mf4_t
+test___riscv_vlse8_v_i8mf4(int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf4(base,bstride,31);
+}
+
+vint8mf2_t
+test___riscv_vlse8_v_i8mf2(int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf2(base,bstride,31);
+}
+
+vint8m1_t
+test___riscv_vlse8_v_i8m1(int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m1(base,bstride,31);
+}
+
+vint8m2_t
+test___riscv_vlse8_v_i8m2(int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m2(base,bstride,31);
+}
+
+vint8m4_t
+test___riscv_vlse8_v_i8m4(int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m4(base,bstride,31);
+}
+
+vint8m8_t
+test___riscv_vlse8_v_i8m8(int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m8(base,bstride,31);
+}
+
+vuint8mf8_t
+test___riscv_vlse8_v_u8mf8(uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf8(base,bstride,31);
+}
+
+vuint8mf4_t
+test___riscv_vlse8_v_u8mf4(uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf4(base,bstride,31);
+}
+
+vuint8mf2_t
+test___riscv_vlse8_v_u8mf2(uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf2(base,bstride,31);
+}
+
+vuint8m1_t
+test___riscv_vlse8_v_u8m1(uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m1(base,bstride,31);
+}
+
+vuint8m2_t
+test___riscv_vlse8_v_u8m2(uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m2(base,bstride,31);
+}
+
+vuint8m4_t
+test___riscv_vlse8_v_u8m4(uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m4(base,bstride,31);
+}
+
+vuint8m8_t
+test___riscv_vlse8_v_u8m8(uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m8(base,bstride,31);
+}
+
+vint16mf4_t
+test___riscv_vlse16_v_i16mf4(int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf4(base,bstride,31);
+}
+
+vint16mf2_t
+test___riscv_vlse16_v_i16mf2(int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf2(base,bstride,31);
+}
+
+vint16m1_t
+test___riscv_vlse16_v_i16m1(int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m1(base,bstride,31);
+}
+
+vint16m2_t
+test___riscv_vlse16_v_i16m2(int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m2(base,bstride,31);
+}
+
+vint16m4_t
+test___riscv_vlse16_v_i16m4(int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m4(base,bstride,31);
+}
+
+vint16m8_t
+test___riscv_vlse16_v_i16m8(int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m8(base,bstride,31);
+}
+
+vuint16mf4_t
+test___riscv_vlse16_v_u16mf4(uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf4(base,bstride,31);
+}
+
+vuint16mf2_t
+test___riscv_vlse16_v_u16mf2(uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf2(base,bstride,31);
+}
+
+vuint16m1_t
+test___riscv_vlse16_v_u16m1(uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m1(base,bstride,31);
+}
+
+vuint16m2_t
+test___riscv_vlse16_v_u16m2(uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m2(base,bstride,31);
+}
+
+vuint16m4_t
+test___riscv_vlse16_v_u16m4(uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m4(base,bstride,31);
+}
+
+vuint16m8_t
+test___riscv_vlse16_v_u16m8(uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m8(base,bstride,31);
+}
+
+vint32mf2_t
+test___riscv_vlse32_v_i32mf2(int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32mf2(base,bstride,31);
+}
+
+vint32m1_t
+test___riscv_vlse32_v_i32m1(int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m1(base,bstride,31);
+}
+
+vint32m2_t
+test___riscv_vlse32_v_i32m2(int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m2(base,bstride,31);
+}
+
+vint32m4_t
+test___riscv_vlse32_v_i32m4(int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m4(base,bstride,31);
+}
+
+vint32m8_t
+test___riscv_vlse32_v_i32m8(int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m8(base,bstride,31);
+}
+
+vuint32mf2_t
+test___riscv_vlse32_v_u32mf2(uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32mf2(base,bstride,31);
+}
+
+vuint32m1_t
+test___riscv_vlse32_v_u32m1(uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m1(base,bstride,31);
+}
+
+vuint32m2_t
+test___riscv_vlse32_v_u32m2(uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m2(base,bstride,31);
+}
+
+vuint32m4_t
+test___riscv_vlse32_v_u32m4(uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m4(base,bstride,31);
+}
+
+vuint32m8_t
+test___riscv_vlse32_v_u32m8(uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m8(base,bstride,31);
+}
+
+vfloat32mf2_t
+test___riscv_vlse32_v_f32mf2(float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32mf2(base,bstride,31);
+}
+
+vfloat32m1_t
+test___riscv_vlse32_v_f32m1(float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m1(base,bstride,31);
+}
+
+vfloat32m2_t
+test___riscv_vlse32_v_f32m2(float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m2(base,bstride,31);
+}
+
+vfloat32m4_t
+test___riscv_vlse32_v_f32m4(float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m4(base,bstride,31);
+}
+
+vfloat32m8_t
+test___riscv_vlse32_v_f32m8(float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m8(base,bstride,31);
+}
+
+vint64m1_t
+test___riscv_vlse64_v_i64m1(int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m1(base,bstride,31);
+}
+
+vint64m2_t
+test___riscv_vlse64_v_i64m2(int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m2(base,bstride,31);
+}
+
+vint64m4_t
+test___riscv_vlse64_v_i64m4(int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m4(base,bstride,31);
+}
+
+vint64m8_t
+test___riscv_vlse64_v_i64m8(int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m8(base,bstride,31);
+}
+
+vuint64m1_t
+test___riscv_vlse64_v_u64m1(uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m1(base,bstride,31);
+}
+
+vuint64m2_t
+test___riscv_vlse64_v_u64m2(uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m2(base,bstride,31);
+}
+
+vuint64m4_t
+test___riscv_vlse64_v_u64m4(uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m4(base,bstride,31);
+}
+
+vuint64m8_t
+test___riscv_vlse64_v_u64m8(uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m8(base,bstride,31);
+}
+
+vfloat64m1_t
+test___riscv_vlse64_v_f64m1(double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m1(base,bstride,31);
+}
+
+vfloat64m2_t
+test___riscv_vlse64_v_f64m2(double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m2(base,bstride,31);
+}
+
+vfloat64m4_t
+test___riscv_vlse64_v_f64m4(double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m4(base,bstride,31);
+}
+
+vfloat64m8_t
+test___riscv_vlse64_v_f64m8(double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m8(base,bstride,31);
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vlse-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse-3.c
new file mode 100644
index 0000000..2c19375
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse-3.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vlse8_v_i8mf8(int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf8(base,bstride,32);
+}
+
+vint8mf4_t
+test___riscv_vlse8_v_i8mf4(int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf4(base,bstride,32);
+}
+
+vint8mf2_t
+test___riscv_vlse8_v_i8mf2(int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf2(base,bstride,32);
+}
+
+vint8m1_t
+test___riscv_vlse8_v_i8m1(int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m1(base,bstride,32);
+}
+
+vint8m2_t
+test___riscv_vlse8_v_i8m2(int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m2(base,bstride,32);
+}
+
+vint8m4_t
+test___riscv_vlse8_v_i8m4(int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m4(base,bstride,32);
+}
+
+vint8m8_t
+test___riscv_vlse8_v_i8m8(int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m8(base,bstride,32);
+}
+
+vuint8mf8_t
+test___riscv_vlse8_v_u8mf8(uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf8(base,bstride,32);
+}
+
+vuint8mf4_t
+test___riscv_vlse8_v_u8mf4(uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf4(base,bstride,32);
+}
+
+vuint8mf2_t
+test___riscv_vlse8_v_u8mf2(uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf2(base,bstride,32);
+}
+
+vuint8m1_t
+test___riscv_vlse8_v_u8m1(uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m1(base,bstride,32);
+}
+
+vuint8m2_t
+test___riscv_vlse8_v_u8m2(uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m2(base,bstride,32);
+}
+
+vuint8m4_t
+test___riscv_vlse8_v_u8m4(uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m4(base,bstride,32);
+}
+
+vuint8m8_t
+test___riscv_vlse8_v_u8m8(uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m8(base,bstride,32);
+}
+
+vint16mf4_t
+test___riscv_vlse16_v_i16mf4(int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf4(base,bstride,32);
+}
+
+vint16mf2_t
+test___riscv_vlse16_v_i16mf2(int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf2(base,bstride,32);
+}
+
+vint16m1_t
+test___riscv_vlse16_v_i16m1(int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m1(base,bstride,32);
+}
+
+vint16m2_t
+test___riscv_vlse16_v_i16m2(int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m2(base,bstride,32);
+}
+
+vint16m4_t
+test___riscv_vlse16_v_i16m4(int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m4(base,bstride,32);
+}
+
+vint16m8_t
+test___riscv_vlse16_v_i16m8(int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m8(base,bstride,32);
+}
+
+vuint16mf4_t
+test___riscv_vlse16_v_u16mf4(uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf4(base,bstride,32);
+}
+
+vuint16mf2_t
+test___riscv_vlse16_v_u16mf2(uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf2(base,bstride,32);
+}
+
+vuint16m1_t
+test___riscv_vlse16_v_u16m1(uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m1(base,bstride,32);
+}
+
+vuint16m2_t
+test___riscv_vlse16_v_u16m2(uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m2(base,bstride,32);
+}
+
+vuint16m4_t
+test___riscv_vlse16_v_u16m4(uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m4(base,bstride,32);
+}
+
+vuint16m8_t
+test___riscv_vlse16_v_u16m8(uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m8(base,bstride,32);
+}
+
+vint32mf2_t
+test___riscv_vlse32_v_i32mf2(int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32mf2(base,bstride,32);
+}
+
+vint32m1_t
+test___riscv_vlse32_v_i32m1(int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m1(base,bstride,32);
+}
+
+vint32m2_t
+test___riscv_vlse32_v_i32m2(int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m2(base,bstride,32);
+}
+
+vint32m4_t
+test___riscv_vlse32_v_i32m4(int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m4(base,bstride,32);
+}
+
+vint32m8_t
+test___riscv_vlse32_v_i32m8(int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m8(base,bstride,32);
+}
+
+vuint32mf2_t
+test___riscv_vlse32_v_u32mf2(uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32mf2(base,bstride,32);
+}
+
+vuint32m1_t
+test___riscv_vlse32_v_u32m1(uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m1(base,bstride,32);
+}
+
+vuint32m2_t
+test___riscv_vlse32_v_u32m2(uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m2(base,bstride,32);
+}
+
+vuint32m4_t
+test___riscv_vlse32_v_u32m4(uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m4(base,bstride,32);
+}
+
+vuint32m8_t
+test___riscv_vlse32_v_u32m8(uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m8(base,bstride,32);
+}
+
+vfloat32mf2_t
+test___riscv_vlse32_v_f32mf2(float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32mf2(base,bstride,32);
+}
+
+vfloat32m1_t
+test___riscv_vlse32_v_f32m1(float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m1(base,bstride,32);
+}
+
+vfloat32m2_t
+test___riscv_vlse32_v_f32m2(float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m2(base,bstride,32);
+}
+
+vfloat32m4_t
+test___riscv_vlse32_v_f32m4(float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m4(base,bstride,32);
+}
+
+vfloat32m8_t
+test___riscv_vlse32_v_f32m8(float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m8(base,bstride,32);
+}
+
+vint64m1_t
+test___riscv_vlse64_v_i64m1(int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m1(base,bstride,32);
+}
+
+vint64m2_t
+test___riscv_vlse64_v_i64m2(int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m2(base,bstride,32);
+}
+
+vint64m4_t
+test___riscv_vlse64_v_i64m4(int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m4(base,bstride,32);
+}
+
+vint64m8_t
+test___riscv_vlse64_v_i64m8(int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m8(base,bstride,32);
+}
+
+vuint64m1_t
+test___riscv_vlse64_v_u64m1(uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m1(base,bstride,32);
+}
+
+vuint64m2_t
+test___riscv_vlse64_v_u64m2(uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m2(base,bstride,32);
+}
+
+vuint64m4_t
+test___riscv_vlse64_v_u64m4(uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m4(base,bstride,32);
+}
+
+vuint64m8_t
+test___riscv_vlse64_v_u64m8(uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m8(base,bstride,32);
+}
+
+vfloat64m1_t
+test___riscv_vlse64_v_f64m1(double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m1(base,bstride,32);
+}
+
+vfloat64m2_t
+test___riscv_vlse64_v_f64m2(double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m2(base,bstride,32);
+}
+
+vfloat64m4_t
+test___riscv_vlse64_v_f64m4(double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m4(base,bstride,32);
+}
+
+vfloat64m8_t
+test___riscv_vlse64_v_f64m8(double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m8(base,bstride,32);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vlse-vsse-constraint-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse-vsse-constraint-1.c
new file mode 100644
index 0000000..0b88a76
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse-vsse-constraint-1.c
@@ -0,0 +1,113 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
+
+#include "riscv_vector.h"
+
+/*
+** f1:
+**	vsetivli\tzero,4,e32,m1,tu,ma
+**	vlse32\.v\tv[0-9]+,0\([a-x0-9]+\),\s*zero
+**	vlse32\.v\tv[0-9]+,0\([a-x0-9]+\),\s*zero
+**	vsse32\.v\tv[0-9]+,0\([a-x0-9]+\),\s*zero
+**	ret
+*/
+void f1 (float * in, float *out)
+{
+    vfloat32m1_t v = __riscv_vlse32_v_f32m1 (in, 0, 4);
+    vfloat32m1_t v2 = __riscv_vlse32_v_f32m1_tu (v, in, 0, 4);
+    __riscv_vsse32_v_f32m1 (out, 0, v2, 4);
+}
+
+/*
+** f2:
+**	vsetvli\t[a-x0-9]+,zero,e8,mf4,ta,ma
+**	vlm.v\tv[0-9]+,0\([a-x0-9]+\)
+**  li\t[a-x0-9]+,\s*7
+**	vsetivli\tzero,4,e32,m1,ta,ma
+**	vlse32.v\tv[0-9]+,0\([a-x0-9]+\),\s*[a-x0-9]+,v0.t
+**	vsse32.v\tv[0-9]+,0\([a-x0-9]+\),\s*[a-x0-9]+
+**	ret
+*/
+void f2 (float * in, float *out)
+{
+    vbool32_t mask = *(vbool32_t*)in;
+    asm volatile ("":::"memory");
+    vfloat32m1_t v = __riscv_vlse32_v_f32m1 (in, 7, 4);
+    vfloat32m1_t v2 = __riscv_vlse32_v_f32m1_m (mask, in, 7, 4);
+    __riscv_vsse32_v_f32m1 (out, 7, v2, 4);
+}
+
+
+/*
+** f3:
+**	vsetvli\t[a-x0-9]+,zero,e8,mf4,ta,ma
+**	vlm.v\tv[0-9]+,0\([a-x0-9]+\)
+**	vsetivli\tzero,4,e32,m1,tu,mu
+**	vlse32\.v\tv[0-9]+,0\([a-x0-9]+\),zero
+**	vlse32\.v\tv[0-9]+,0\([a-x0-9]+\),zero,v0.t
+**	vsse32\.v\tv[0-9]+,0\([a-x0-9]+\),zero
+**	ret
+*/
+void f3 (float * in, float *out)
+{
+    vbool32_t mask = *(vbool32_t*)in;
+    asm volatile ("":::"memory");
+    vfloat32m1_t v = __riscv_vlse32_v_f32m1 (in, 0, 4);
+    vfloat32m1_t v2 = __riscv_vlse32_v_f32m1_tumu (mask, v, in, 0, 4);
+    __riscv_vsse32_v_f32m1 (out, 0, v2, 4);
+}
+
+/*
+** f4:
+**  li\s+[a-x0-9]+,\s*17
+**	vsetivli\tzero,4,e8,mf8,tu,ma
+**	vlse8\.v\tv[0-9]+,0\([a-x0-9]+\),[a-x0-9]+
+**	vlse8\.v\tv[0-9]+,0\([a-x0-9]+\),[a-x0-9]+
+**	vsse8\.v\tv[0-9]+,0\([a-x0-9]+\),[a-x0-9]+
+**	ret
+*/
+void f4 (int8_t * in, int8_t *out)
+{
+    vint8mf8_t v = __riscv_vlse8_v_i8mf8 (in, 17, 4);
+    vint8mf8_t v2 = __riscv_vlse8_v_i8mf8_tu (v, in, 17, 4);
+    __riscv_vsse8_v_i8mf8 (out, 17, v2, 4);
+}
+
+/*
+** f5:
+**	vsetvli\t[a-x0-9]+,zero,e8,mf8,ta,ma
+**	vlm.v\tv[0-9]+,0\([a-x0-9]+\)
+**	vsetivli\tzero,4,e8,mf8,ta,ma
+**	vlse8.v\tv[0-9]+,0\([a-x0-9]+\),zero,v0.t
+**	vsse8.v\tv[0-9]+,0\([a-x0-9]+\),zero
+**	ret
+*/
+void f5 (int8_t * in, int8_t *out)
+{
+    vbool64_t mask = *(vbool64_t*)in;
+    asm volatile ("":::"memory");
+    vint8mf8_t v = __riscv_vlse8_v_i8mf8 (in, 0, 4);
+    vint8mf8_t v2 = __riscv_vlse8_v_i8mf8_m (mask, in, 0, 4);
+    __riscv_vsse8_v_i8mf8 (out, 0, v2, 4);
+}
+
+/*
+** f6:
+**	vsetvli\t[a-x0-9]+,zero,e8,mf8,ta,ma
+**	vlm.v\tv[0-9]+,0\([a-x0-9]+\)
+**  li\s+[a-x0-9]+,\s*999
+**	vsetivli\tzero,4,e8,mf8,tu,mu
+**	vlse8\.v\tv[0-9]+,0\([a-x0-9]+\),\s*[a-x0-9]+
+**	vlse8\.v\tv[0-9]+,0\([a-x0-9]+\),\s*[a-x0-9]+,v0.t
+**	vsse8\.v\tv[0-9]+,0\([a-x0-9]+\),\s*[a-x0-9]+,v0.t
+**	ret
+*/
+void f6 (int8_t * in, int8_t *out)
+{
+    vbool64_t mask = *(vbool64_t*)in;
+    asm volatile ("":::"memory");
+    vint8mf8_t v = __riscv_vlse8_v_i8mf8 (in, 999, 4);
+    vint8mf8_t v2 = __riscv_vlse8_v_i8mf8_tumu (mask, v, in, 999, 4);
+    __riscv_vsse8_v_i8mf8_m (mask,out, 999, v2, 4);
+}
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_m-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_m-1.c
new file mode 100644
index 0000000..573cf8a
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_m-1.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vlse8_v_i8mf8_m(vbool64_t mask,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf8_m(mask,base,bstride,vl);
+}
+
+vint8mf4_t
+test___riscv_vlse8_v_i8mf4_m(vbool32_t mask,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf4_m(mask,base,bstride,vl);
+}
+
+vint8mf2_t
+test___riscv_vlse8_v_i8mf2_m(vbool16_t mask,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf2_m(mask,base,bstride,vl);
+}
+
+vint8m1_t
+test___riscv_vlse8_v_i8m1_m(vbool8_t mask,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m1_m(mask,base,bstride,vl);
+}
+
+vint8m2_t
+test___riscv_vlse8_v_i8m2_m(vbool4_t mask,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m2_m(mask,base,bstride,vl);
+}
+
+vint8m4_t
+test___riscv_vlse8_v_i8m4_m(vbool2_t mask,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m4_m(mask,base,bstride,vl);
+}
+
+vint8m8_t
+test___riscv_vlse8_v_i8m8_m(vbool1_t mask,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m8_m(mask,base,bstride,vl);
+}
+
+vuint8mf8_t
+test___riscv_vlse8_v_u8mf8_m(vbool64_t mask,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf8_m(mask,base,bstride,vl);
+}
+
+vuint8mf4_t
+test___riscv_vlse8_v_u8mf4_m(vbool32_t mask,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf4_m(mask,base,bstride,vl);
+}
+
+vuint8mf2_t
+test___riscv_vlse8_v_u8mf2_m(vbool16_t mask,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf2_m(mask,base,bstride,vl);
+}
+
+vuint8m1_t
+test___riscv_vlse8_v_u8m1_m(vbool8_t mask,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m1_m(mask,base,bstride,vl);
+}
+
+vuint8m2_t
+test___riscv_vlse8_v_u8m2_m(vbool4_t mask,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m2_m(mask,base,bstride,vl);
+}
+
+vuint8m4_t
+test___riscv_vlse8_v_u8m4_m(vbool2_t mask,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m4_m(mask,base,bstride,vl);
+}
+
+vuint8m8_t
+test___riscv_vlse8_v_u8m8_m(vbool1_t mask,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m8_m(mask,base,bstride,vl);
+}
+
+vint16mf4_t
+test___riscv_vlse16_v_i16mf4_m(vbool64_t mask,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf4_m(mask,base,bstride,vl);
+}
+
+vint16mf2_t
+test___riscv_vlse16_v_i16mf2_m(vbool32_t mask,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf2_m(mask,base,bstride,vl);
+}
+
+vint16m1_t
+test___riscv_vlse16_v_i16m1_m(vbool16_t mask,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m1_m(mask,base,bstride,vl);
+}
+
+vint16m2_t
+test___riscv_vlse16_v_i16m2_m(vbool8_t mask,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m2_m(mask,base,bstride,vl);
+}
+
+vint16m4_t
+test___riscv_vlse16_v_i16m4_m(vbool4_t mask,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m4_m(mask,base,bstride,vl);
+}
+
+vint16m8_t
+test___riscv_vlse16_v_i16m8_m(vbool2_t mask,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m8_m(mask,base,bstride,vl);
+}
+
+vuint16mf4_t
+test___riscv_vlse16_v_u16mf4_m(vbool64_t mask,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf4_m(mask,base,bstride,vl);
+}
+
+vuint16mf2_t
+test___riscv_vlse16_v_u16mf2_m(vbool32_t mask,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf2_m(mask,base,bstride,vl);
+}
+
+vuint16m1_t
+test___riscv_vlse16_v_u16m1_m(vbool16_t mask,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m1_m(mask,base,bstride,vl);
+}
+
+vuint16m2_t
+test___riscv_vlse16_v_u16m2_m(vbool8_t mask,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m2_m(mask,base,bstride,vl);
+}
+
+vuint16m4_t
+test___riscv_vlse16_v_u16m4_m(vbool4_t mask,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m4_m(mask,base,bstride,vl);
+}
+
+vuint16m8_t
+test___riscv_vlse16_v_u16m8_m(vbool2_t mask,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m8_m(mask,base,bstride,vl);
+}
+
+vint32mf2_t
+test___riscv_vlse32_v_i32mf2_m(vbool64_t mask,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32mf2_m(mask,base,bstride,vl);
+}
+
+vint32m1_t
+test___riscv_vlse32_v_i32m1_m(vbool32_t mask,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m1_m(mask,base,bstride,vl);
+}
+
+vint32m2_t
+test___riscv_vlse32_v_i32m2_m(vbool16_t mask,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m2_m(mask,base,bstride,vl);
+}
+
+vint32m4_t
+test___riscv_vlse32_v_i32m4_m(vbool8_t mask,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m4_m(mask,base,bstride,vl);
+}
+
+vint32m8_t
+test___riscv_vlse32_v_i32m8_m(vbool4_t mask,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m8_m(mask,base,bstride,vl);
+}
+
+vuint32mf2_t
+test___riscv_vlse32_v_u32mf2_m(vbool64_t mask,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32mf2_m(mask,base,bstride,vl);
+}
+
+vuint32m1_t
+test___riscv_vlse32_v_u32m1_m(vbool32_t mask,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m1_m(mask,base,bstride,vl);
+}
+
+vuint32m2_t
+test___riscv_vlse32_v_u32m2_m(vbool16_t mask,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m2_m(mask,base,bstride,vl);
+}
+
+vuint32m4_t
+test___riscv_vlse32_v_u32m4_m(vbool8_t mask,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m4_m(mask,base,bstride,vl);
+}
+
+vuint32m8_t
+test___riscv_vlse32_v_u32m8_m(vbool4_t mask,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m8_m(mask,base,bstride,vl);
+}
+
+vfloat32mf2_t
+test___riscv_vlse32_v_f32mf2_m(vbool64_t mask,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32mf2_m(mask,base,bstride,vl);
+}
+
+vfloat32m1_t
+test___riscv_vlse32_v_f32m1_m(vbool32_t mask,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m1_m(mask,base,bstride,vl);
+}
+
+vfloat32m2_t
+test___riscv_vlse32_v_f32m2_m(vbool16_t mask,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m2_m(mask,base,bstride,vl);
+}
+
+vfloat32m4_t
+test___riscv_vlse32_v_f32m4_m(vbool8_t mask,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m4_m(mask,base,bstride,vl);
+}
+
+vfloat32m8_t
+test___riscv_vlse32_v_f32m8_m(vbool4_t mask,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m8_m(mask,base,bstride,vl);
+}
+
+vint64m1_t
+test___riscv_vlse64_v_i64m1_m(vbool64_t mask,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m1_m(mask,base,bstride,vl);
+}
+
+vint64m2_t
+test___riscv_vlse64_v_i64m2_m(vbool32_t mask,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m2_m(mask,base,bstride,vl);
+}
+
+vint64m4_t
+test___riscv_vlse64_v_i64m4_m(vbool16_t mask,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m4_m(mask,base,bstride,vl);
+}
+
+vint64m8_t
+test___riscv_vlse64_v_i64m8_m(vbool8_t mask,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m8_m(mask,base,bstride,vl);
+}
+
+vuint64m1_t
+test___riscv_vlse64_v_u64m1_m(vbool64_t mask,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m1_m(mask,base,bstride,vl);
+}
+
+vuint64m2_t
+test___riscv_vlse64_v_u64m2_m(vbool32_t mask,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m2_m(mask,base,bstride,vl);
+}
+
+vuint64m4_t
+test___riscv_vlse64_v_u64m4_m(vbool16_t mask,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m4_m(mask,base,bstride,vl);
+}
+
+vuint64m8_t
+test___riscv_vlse64_v_u64m8_m(vbool8_t mask,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m8_m(mask,base,bstride,vl);
+}
+
+vfloat64m1_t
+test___riscv_vlse64_v_f64m1_m(vbool64_t mask,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m1_m(mask,base,bstride,vl);
+}
+
+vfloat64m2_t
+test___riscv_vlse64_v_f64m2_m(vbool32_t mask,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m2_m(mask,base,bstride,vl);
+}
+
+vfloat64m4_t
+test___riscv_vlse64_v_f64m4_m(vbool16_t mask,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m4_m(mask,base,bstride,vl);
+}
+
+vfloat64m8_t
+test___riscv_vlse64_v_f64m8_m(vbool8_t mask,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m8_m(mask,base,bstride,vl);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_m-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_m-2.c
new file mode 100644
index 0000000..cc40364
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_m-2.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vlse8_v_i8mf8_m(vbool64_t mask,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf8_m(mask,base,bstride,31);
+}
+
+vint8mf4_t
+test___riscv_vlse8_v_i8mf4_m(vbool32_t mask,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf4_m(mask,base,bstride,31);
+}
+
+vint8mf2_t
+test___riscv_vlse8_v_i8mf2_m(vbool16_t mask,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf2_m(mask,base,bstride,31);
+}
+
+vint8m1_t
+test___riscv_vlse8_v_i8m1_m(vbool8_t mask,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m1_m(mask,base,bstride,31);
+}
+
+vint8m2_t
+test___riscv_vlse8_v_i8m2_m(vbool4_t mask,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m2_m(mask,base,bstride,31);
+}
+
+vint8m4_t
+test___riscv_vlse8_v_i8m4_m(vbool2_t mask,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m4_m(mask,base,bstride,31);
+}
+
+vint8m8_t
+test___riscv_vlse8_v_i8m8_m(vbool1_t mask,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m8_m(mask,base,bstride,31);
+}
+
+vuint8mf8_t
+test___riscv_vlse8_v_u8mf8_m(vbool64_t mask,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf8_m(mask,base,bstride,31);
+}
+
+vuint8mf4_t
+test___riscv_vlse8_v_u8mf4_m(vbool32_t mask,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf4_m(mask,base,bstride,31);
+}
+
+vuint8mf2_t
+test___riscv_vlse8_v_u8mf2_m(vbool16_t mask,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf2_m(mask,base,bstride,31);
+}
+
+vuint8m1_t
+test___riscv_vlse8_v_u8m1_m(vbool8_t mask,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m1_m(mask,base,bstride,31);
+}
+
+vuint8m2_t
+test___riscv_vlse8_v_u8m2_m(vbool4_t mask,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m2_m(mask,base,bstride,31);
+}
+
+vuint8m4_t
+test___riscv_vlse8_v_u8m4_m(vbool2_t mask,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m4_m(mask,base,bstride,31);
+}
+
+vuint8m8_t
+test___riscv_vlse8_v_u8m8_m(vbool1_t mask,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m8_m(mask,base,bstride,31);
+}
+
+vint16mf4_t
+test___riscv_vlse16_v_i16mf4_m(vbool64_t mask,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf4_m(mask,base,bstride,31);
+}
+
+vint16mf2_t
+test___riscv_vlse16_v_i16mf2_m(vbool32_t mask,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf2_m(mask,base,bstride,31);
+}
+
+vint16m1_t
+test___riscv_vlse16_v_i16m1_m(vbool16_t mask,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m1_m(mask,base,bstride,31);
+}
+
+vint16m2_t
+test___riscv_vlse16_v_i16m2_m(vbool8_t mask,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m2_m(mask,base,bstride,31);
+}
+
+vint16m4_t
+test___riscv_vlse16_v_i16m4_m(vbool4_t mask,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m4_m(mask,base,bstride,31);
+}
+
+vint16m8_t
+test___riscv_vlse16_v_i16m8_m(vbool2_t mask,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m8_m(mask,base,bstride,31);
+}
+
+vuint16mf4_t
+test___riscv_vlse16_v_u16mf4_m(vbool64_t mask,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf4_m(mask,base,bstride,31);
+}
+
+vuint16mf2_t
+test___riscv_vlse16_v_u16mf2_m(vbool32_t mask,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf2_m(mask,base,bstride,31);
+}
+
+vuint16m1_t
+test___riscv_vlse16_v_u16m1_m(vbool16_t mask,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m1_m(mask,base,bstride,31);
+}
+
+vuint16m2_t
+test___riscv_vlse16_v_u16m2_m(vbool8_t mask,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m2_m(mask,base,bstride,31);
+}
+
+vuint16m4_t
+test___riscv_vlse16_v_u16m4_m(vbool4_t mask,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m4_m(mask,base,bstride,31);
+}
+
+vuint16m8_t
+test___riscv_vlse16_v_u16m8_m(vbool2_t mask,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m8_m(mask,base,bstride,31);
+}
+
+vint32mf2_t
+test___riscv_vlse32_v_i32mf2_m(vbool64_t mask,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32mf2_m(mask,base,bstride,31);
+}
+
+vint32m1_t
+test___riscv_vlse32_v_i32m1_m(vbool32_t mask,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m1_m(mask,base,bstride,31);
+}
+
+vint32m2_t
+test___riscv_vlse32_v_i32m2_m(vbool16_t mask,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m2_m(mask,base,bstride,31);
+}
+
+vint32m4_t
+test___riscv_vlse32_v_i32m4_m(vbool8_t mask,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m4_m(mask,base,bstride,31);
+}
+
+vint32m8_t
+test___riscv_vlse32_v_i32m8_m(vbool4_t mask,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m8_m(mask,base,bstride,31);
+}
+
+vuint32mf2_t
+test___riscv_vlse32_v_u32mf2_m(vbool64_t mask,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32mf2_m(mask,base,bstride,31);
+}
+
+vuint32m1_t
+test___riscv_vlse32_v_u32m1_m(vbool32_t mask,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m1_m(mask,base,bstride,31);
+}
+
+vuint32m2_t
+test___riscv_vlse32_v_u32m2_m(vbool16_t mask,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m2_m(mask,base,bstride,31);
+}
+
+vuint32m4_t
+test___riscv_vlse32_v_u32m4_m(vbool8_t mask,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m4_m(mask,base,bstride,31);
+}
+
+vuint32m8_t
+test___riscv_vlse32_v_u32m8_m(vbool4_t mask,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m8_m(mask,base,bstride,31);
+}
+
+vfloat32mf2_t
+test___riscv_vlse32_v_f32mf2_m(vbool64_t mask,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32mf2_m(mask,base,bstride,31);
+}
+
+vfloat32m1_t
+test___riscv_vlse32_v_f32m1_m(vbool32_t mask,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m1_m(mask,base,bstride,31);
+}
+
+vfloat32m2_t
+test___riscv_vlse32_v_f32m2_m(vbool16_t mask,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m2_m(mask,base,bstride,31);
+}
+
+vfloat32m4_t
+test___riscv_vlse32_v_f32m4_m(vbool8_t mask,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m4_m(mask,base,bstride,31);
+}
+
+vfloat32m8_t
+test___riscv_vlse32_v_f32m8_m(vbool4_t mask,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m8_m(mask,base,bstride,31);
+}
+
+vint64m1_t
+test___riscv_vlse64_v_i64m1_m(vbool64_t mask,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m1_m(mask,base,bstride,31);
+}
+
+vint64m2_t
+test___riscv_vlse64_v_i64m2_m(vbool32_t mask,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m2_m(mask,base,bstride,31);
+}
+
+vint64m4_t
+test___riscv_vlse64_v_i64m4_m(vbool16_t mask,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m4_m(mask,base,bstride,31);
+}
+
+vint64m8_t
+test___riscv_vlse64_v_i64m8_m(vbool8_t mask,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m8_m(mask,base,bstride,31);
+}
+
+vuint64m1_t
+test___riscv_vlse64_v_u64m1_m(vbool64_t mask,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m1_m(mask,base,bstride,31);
+}
+
+vuint64m2_t
+test___riscv_vlse64_v_u64m2_m(vbool32_t mask,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m2_m(mask,base,bstride,31);
+}
+
+vuint64m4_t
+test___riscv_vlse64_v_u64m4_m(vbool16_t mask,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m4_m(mask,base,bstride,31);
+}
+
+vuint64m8_t
+test___riscv_vlse64_v_u64m8_m(vbool8_t mask,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m8_m(mask,base,bstride,31);
+}
+
+vfloat64m1_t
+test___riscv_vlse64_v_f64m1_m(vbool64_t mask,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m1_m(mask,base,bstride,31);
+}
+
+vfloat64m2_t
+test___riscv_vlse64_v_f64m2_m(vbool32_t mask,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m2_m(mask,base,bstride,31);
+}
+
+vfloat64m4_t
+test___riscv_vlse64_v_f64m4_m(vbool16_t mask,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m4_m(mask,base,bstride,31);
+}
+
+vfloat64m8_t
+test___riscv_vlse64_v_f64m8_m(vbool8_t mask,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m8_m(mask,base,bstride,31);
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_m-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_m-3.c
new file mode 100644
index 0000000..d289088
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_m-3.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vlse8_v_i8mf8_m(vbool64_t mask,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf8_m(mask,base,bstride,32);
+}
+
+vint8mf4_t
+test___riscv_vlse8_v_i8mf4_m(vbool32_t mask,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf4_m(mask,base,bstride,32);
+}
+
+vint8mf2_t
+test___riscv_vlse8_v_i8mf2_m(vbool16_t mask,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf2_m(mask,base,bstride,32);
+}
+
+vint8m1_t
+test___riscv_vlse8_v_i8m1_m(vbool8_t mask,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m1_m(mask,base,bstride,32);
+}
+
+vint8m2_t
+test___riscv_vlse8_v_i8m2_m(vbool4_t mask,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m2_m(mask,base,bstride,32);
+}
+
+vint8m4_t
+test___riscv_vlse8_v_i8m4_m(vbool2_t mask,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m4_m(mask,base,bstride,32);
+}
+
+vint8m8_t
+test___riscv_vlse8_v_i8m8_m(vbool1_t mask,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m8_m(mask,base,bstride,32);
+}
+
+vuint8mf8_t
+test___riscv_vlse8_v_u8mf8_m(vbool64_t mask,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf8_m(mask,base,bstride,32);
+}
+
+vuint8mf4_t
+test___riscv_vlse8_v_u8mf4_m(vbool32_t mask,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf4_m(mask,base,bstride,32);
+}
+
+vuint8mf2_t
+test___riscv_vlse8_v_u8mf2_m(vbool16_t mask,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf2_m(mask,base,bstride,32);
+}
+
+vuint8m1_t
+test___riscv_vlse8_v_u8m1_m(vbool8_t mask,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m1_m(mask,base,bstride,32);
+}
+
+vuint8m2_t
+test___riscv_vlse8_v_u8m2_m(vbool4_t mask,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m2_m(mask,base,bstride,32);
+}
+
+vuint8m4_t
+test___riscv_vlse8_v_u8m4_m(vbool2_t mask,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m4_m(mask,base,bstride,32);
+}
+
+vuint8m8_t
+test___riscv_vlse8_v_u8m8_m(vbool1_t mask,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m8_m(mask,base,bstride,32);
+}
+
+vint16mf4_t
+test___riscv_vlse16_v_i16mf4_m(vbool64_t mask,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf4_m(mask,base,bstride,32);
+}
+
+vint16mf2_t
+test___riscv_vlse16_v_i16mf2_m(vbool32_t mask,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf2_m(mask,base,bstride,32);
+}
+
+vint16m1_t
+test___riscv_vlse16_v_i16m1_m(vbool16_t mask,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m1_m(mask,base,bstride,32);
+}
+
+vint16m2_t
+test___riscv_vlse16_v_i16m2_m(vbool8_t mask,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m2_m(mask,base,bstride,32);
+}
+
+vint16m4_t
+test___riscv_vlse16_v_i16m4_m(vbool4_t mask,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m4_m(mask,base,bstride,32);
+}
+
+vint16m8_t
+test___riscv_vlse16_v_i16m8_m(vbool2_t mask,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m8_m(mask,base,bstride,32);
+}
+
+vuint16mf4_t
+test___riscv_vlse16_v_u16mf4_m(vbool64_t mask,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf4_m(mask,base,bstride,32);
+}
+
+vuint16mf2_t
+test___riscv_vlse16_v_u16mf2_m(vbool32_t mask,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf2_m(mask,base,bstride,32);
+}
+
+vuint16m1_t
+test___riscv_vlse16_v_u16m1_m(vbool16_t mask,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m1_m(mask,base,bstride,32);
+}
+
+vuint16m2_t
+test___riscv_vlse16_v_u16m2_m(vbool8_t mask,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m2_m(mask,base,bstride,32);
+}
+
+vuint16m4_t
+test___riscv_vlse16_v_u16m4_m(vbool4_t mask,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m4_m(mask,base,bstride,32);
+}
+
+vuint16m8_t
+test___riscv_vlse16_v_u16m8_m(vbool2_t mask,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m8_m(mask,base,bstride,32);
+}
+
+vint32mf2_t
+test___riscv_vlse32_v_i32mf2_m(vbool64_t mask,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32mf2_m(mask,base,bstride,32);
+}
+
+vint32m1_t
+test___riscv_vlse32_v_i32m1_m(vbool32_t mask,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m1_m(mask,base,bstride,32);
+}
+
+vint32m2_t
+test___riscv_vlse32_v_i32m2_m(vbool16_t mask,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m2_m(mask,base,bstride,32);
+}
+
+vint32m4_t
+test___riscv_vlse32_v_i32m4_m(vbool8_t mask,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m4_m(mask,base,bstride,32);
+}
+
+vint32m8_t
+test___riscv_vlse32_v_i32m8_m(vbool4_t mask,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m8_m(mask,base,bstride,32);
+}
+
+vuint32mf2_t
+test___riscv_vlse32_v_u32mf2_m(vbool64_t mask,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32mf2_m(mask,base,bstride,32);
+}
+
+vuint32m1_t
+test___riscv_vlse32_v_u32m1_m(vbool32_t mask,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m1_m(mask,base,bstride,32);
+}
+
+vuint32m2_t
+test___riscv_vlse32_v_u32m2_m(vbool16_t mask,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m2_m(mask,base,bstride,32);
+}
+
+vuint32m4_t
+test___riscv_vlse32_v_u32m4_m(vbool8_t mask,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m4_m(mask,base,bstride,32);
+}
+
+vuint32m8_t
+test___riscv_vlse32_v_u32m8_m(vbool4_t mask,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m8_m(mask,base,bstride,32);
+}
+
+vfloat32mf2_t
+test___riscv_vlse32_v_f32mf2_m(vbool64_t mask,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32mf2_m(mask,base,bstride,32);
+}
+
+vfloat32m1_t
+test___riscv_vlse32_v_f32m1_m(vbool32_t mask,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m1_m(mask,base,bstride,32);
+}
+
+vfloat32m2_t
+test___riscv_vlse32_v_f32m2_m(vbool16_t mask,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m2_m(mask,base,bstride,32);
+}
+
+vfloat32m4_t
+test___riscv_vlse32_v_f32m4_m(vbool8_t mask,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m4_m(mask,base,bstride,32);
+}
+
+vfloat32m8_t
+test___riscv_vlse32_v_f32m8_m(vbool4_t mask,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m8_m(mask,base,bstride,32);
+}
+
+vint64m1_t
+test___riscv_vlse64_v_i64m1_m(vbool64_t mask,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m1_m(mask,base,bstride,32);
+}
+
+vint64m2_t
+test___riscv_vlse64_v_i64m2_m(vbool32_t mask,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m2_m(mask,base,bstride,32);
+}
+
+vint64m4_t
+test___riscv_vlse64_v_i64m4_m(vbool16_t mask,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m4_m(mask,base,bstride,32);
+}
+
+vint64m8_t
+test___riscv_vlse64_v_i64m8_m(vbool8_t mask,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m8_m(mask,base,bstride,32);
+}
+
+vuint64m1_t
+test___riscv_vlse64_v_u64m1_m(vbool64_t mask,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m1_m(mask,base,bstride,32);
+}
+
+vuint64m2_t
+test___riscv_vlse64_v_u64m2_m(vbool32_t mask,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m2_m(mask,base,bstride,32);
+}
+
+vuint64m4_t
+test___riscv_vlse64_v_u64m4_m(vbool16_t mask,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m4_m(mask,base,bstride,32);
+}
+
+vuint64m8_t
+test___riscv_vlse64_v_u64m8_m(vbool8_t mask,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m8_m(mask,base,bstride,32);
+}
+
+vfloat64m1_t
+test___riscv_vlse64_v_f64m1_m(vbool64_t mask,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m1_m(mask,base,bstride,32);
+}
+
+vfloat64m2_t
+test___riscv_vlse64_v_f64m2_m(vbool32_t mask,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m2_m(mask,base,bstride,32);
+}
+
+vfloat64m4_t
+test___riscv_vlse64_v_f64m4_m(vbool16_t mask,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m4_m(mask,base,bstride,32);
+}
+
+vfloat64m8_t
+test___riscv_vlse64_v_f64m8_m(vbool8_t mask,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m8_m(mask,base,bstride,32);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_mu-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_mu-1.c
new file mode 100644
index 0000000..03c2870
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_mu-1.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vlse8_v_i8mf8_mu(vbool64_t mask,vint8mf8_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf8_mu(mask,merge,base,bstride,vl);
+}
+
+vint8mf4_t
+test___riscv_vlse8_v_i8mf4_mu(vbool32_t mask,vint8mf4_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf4_mu(mask,merge,base,bstride,vl);
+}
+
+vint8mf2_t
+test___riscv_vlse8_v_i8mf2_mu(vbool16_t mask,vint8mf2_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf2_mu(mask,merge,base,bstride,vl);
+}
+
+vint8m1_t
+test___riscv_vlse8_v_i8m1_mu(vbool8_t mask,vint8m1_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m1_mu(mask,merge,base,bstride,vl);
+}
+
+vint8m2_t
+test___riscv_vlse8_v_i8m2_mu(vbool4_t mask,vint8m2_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m2_mu(mask,merge,base,bstride,vl);
+}
+
+vint8m4_t
+test___riscv_vlse8_v_i8m4_mu(vbool2_t mask,vint8m4_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m4_mu(mask,merge,base,bstride,vl);
+}
+
+vint8m8_t
+test___riscv_vlse8_v_i8m8_mu(vbool1_t mask,vint8m8_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m8_mu(mask,merge,base,bstride,vl);
+}
+
+vuint8mf8_t
+test___riscv_vlse8_v_u8mf8_mu(vbool64_t mask,vuint8mf8_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf8_mu(mask,merge,base,bstride,vl);
+}
+
+vuint8mf4_t
+test___riscv_vlse8_v_u8mf4_mu(vbool32_t mask,vuint8mf4_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf4_mu(mask,merge,base,bstride,vl);
+}
+
+vuint8mf2_t
+test___riscv_vlse8_v_u8mf2_mu(vbool16_t mask,vuint8mf2_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf2_mu(mask,merge,base,bstride,vl);
+}
+
+vuint8m1_t
+test___riscv_vlse8_v_u8m1_mu(vbool8_t mask,vuint8m1_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m1_mu(mask,merge,base,bstride,vl);
+}
+
+vuint8m2_t
+test___riscv_vlse8_v_u8m2_mu(vbool4_t mask,vuint8m2_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m2_mu(mask,merge,base,bstride,vl);
+}
+
+vuint8m4_t
+test___riscv_vlse8_v_u8m4_mu(vbool2_t mask,vuint8m4_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m4_mu(mask,merge,base,bstride,vl);
+}
+
+vuint8m8_t
+test___riscv_vlse8_v_u8m8_mu(vbool1_t mask,vuint8m8_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m8_mu(mask,merge,base,bstride,vl);
+}
+
+vint16mf4_t
+test___riscv_vlse16_v_i16mf4_mu(vbool64_t mask,vint16mf4_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf4_mu(mask,merge,base,bstride,vl);
+}
+
+vint16mf2_t
+test___riscv_vlse16_v_i16mf2_mu(vbool32_t mask,vint16mf2_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf2_mu(mask,merge,base,bstride,vl);
+}
+
+vint16m1_t
+test___riscv_vlse16_v_i16m1_mu(vbool16_t mask,vint16m1_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m1_mu(mask,merge,base,bstride,vl);
+}
+
+vint16m2_t
+test___riscv_vlse16_v_i16m2_mu(vbool8_t mask,vint16m2_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m2_mu(mask,merge,base,bstride,vl);
+}
+
+vint16m4_t
+test___riscv_vlse16_v_i16m4_mu(vbool4_t mask,vint16m4_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m4_mu(mask,merge,base,bstride,vl);
+}
+
+vint16m8_t
+test___riscv_vlse16_v_i16m8_mu(vbool2_t mask,vint16m8_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m8_mu(mask,merge,base,bstride,vl);
+}
+
+vuint16mf4_t
+test___riscv_vlse16_v_u16mf4_mu(vbool64_t mask,vuint16mf4_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf4_mu(mask,merge,base,bstride,vl);
+}
+
+vuint16mf2_t
+test___riscv_vlse16_v_u16mf2_mu(vbool32_t mask,vuint16mf2_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf2_mu(mask,merge,base,bstride,vl);
+}
+
+vuint16m1_t
+test___riscv_vlse16_v_u16m1_mu(vbool16_t mask,vuint16m1_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m1_mu(mask,merge,base,bstride,vl);
+}
+
+vuint16m2_t
+test___riscv_vlse16_v_u16m2_mu(vbool8_t mask,vuint16m2_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m2_mu(mask,merge,base,bstride,vl);
+}
+
+vuint16m4_t
+test___riscv_vlse16_v_u16m4_mu(vbool4_t mask,vuint16m4_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m4_mu(mask,merge,base,bstride,vl);
+}
+
+vuint16m8_t
+test___riscv_vlse16_v_u16m8_mu(vbool2_t mask,vuint16m8_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m8_mu(mask,merge,base,bstride,vl);
+}
+
+vint32mf2_t
+test___riscv_vlse32_v_i32mf2_mu(vbool64_t mask,vint32mf2_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32mf2_mu(mask,merge,base,bstride,vl);
+}
+
+vint32m1_t
+test___riscv_vlse32_v_i32m1_mu(vbool32_t mask,vint32m1_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m1_mu(mask,merge,base,bstride,vl);
+}
+
+vint32m2_t
+test___riscv_vlse32_v_i32m2_mu(vbool16_t mask,vint32m2_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m2_mu(mask,merge,base,bstride,vl);
+}
+
+vint32m4_t
+test___riscv_vlse32_v_i32m4_mu(vbool8_t mask,vint32m4_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m4_mu(mask,merge,base,bstride,vl);
+}
+
+vint32m8_t
+test___riscv_vlse32_v_i32m8_mu(vbool4_t mask,vint32m8_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m8_mu(mask,merge,base,bstride,vl);
+}
+
+vuint32mf2_t
+test___riscv_vlse32_v_u32mf2_mu(vbool64_t mask,vuint32mf2_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32mf2_mu(mask,merge,base,bstride,vl);
+}
+
+vuint32m1_t
+test___riscv_vlse32_v_u32m1_mu(vbool32_t mask,vuint32m1_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m1_mu(mask,merge,base,bstride,vl);
+}
+
+vuint32m2_t
+test___riscv_vlse32_v_u32m2_mu(vbool16_t mask,vuint32m2_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m2_mu(mask,merge,base,bstride,vl);
+}
+
+vuint32m4_t
+test___riscv_vlse32_v_u32m4_mu(vbool8_t mask,vuint32m4_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m4_mu(mask,merge,base,bstride,vl);
+}
+
+vuint32m8_t
+test___riscv_vlse32_v_u32m8_mu(vbool4_t mask,vuint32m8_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m8_mu(mask,merge,base,bstride,vl);
+}
+
+vfloat32mf2_t
+test___riscv_vlse32_v_f32mf2_mu(vbool64_t mask,vfloat32mf2_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32mf2_mu(mask,merge,base,bstride,vl);
+}
+
+vfloat32m1_t
+test___riscv_vlse32_v_f32m1_mu(vbool32_t mask,vfloat32m1_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m1_mu(mask,merge,base,bstride,vl);
+}
+
+vfloat32m2_t
+test___riscv_vlse32_v_f32m2_mu(vbool16_t mask,vfloat32m2_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m2_mu(mask,merge,base,bstride,vl);
+}
+
+vfloat32m4_t
+test___riscv_vlse32_v_f32m4_mu(vbool8_t mask,vfloat32m4_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m4_mu(mask,merge,base,bstride,vl);
+}
+
+vfloat32m8_t
+test___riscv_vlse32_v_f32m8_mu(vbool4_t mask,vfloat32m8_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m8_mu(mask,merge,base,bstride,vl);
+}
+
+vint64m1_t
+test___riscv_vlse64_v_i64m1_mu(vbool64_t mask,vint64m1_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m1_mu(mask,merge,base,bstride,vl);
+}
+
+vint64m2_t
+test___riscv_vlse64_v_i64m2_mu(vbool32_t mask,vint64m2_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m2_mu(mask,merge,base,bstride,vl);
+}
+
+vint64m4_t
+test___riscv_vlse64_v_i64m4_mu(vbool16_t mask,vint64m4_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m4_mu(mask,merge,base,bstride,vl);
+}
+
+vint64m8_t
+test___riscv_vlse64_v_i64m8_mu(vbool8_t mask,vint64m8_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m8_mu(mask,merge,base,bstride,vl);
+}
+
+vuint64m1_t
+test___riscv_vlse64_v_u64m1_mu(vbool64_t mask,vuint64m1_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m1_mu(mask,merge,base,bstride,vl);
+}
+
+vuint64m2_t
+test___riscv_vlse64_v_u64m2_mu(vbool32_t mask,vuint64m2_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m2_mu(mask,merge,base,bstride,vl);
+}
+
+vuint64m4_t
+test___riscv_vlse64_v_u64m4_mu(vbool16_t mask,vuint64m4_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m4_mu(mask,merge,base,bstride,vl);
+}
+
+vuint64m8_t
+test___riscv_vlse64_v_u64m8_mu(vbool8_t mask,vuint64m8_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m8_mu(mask,merge,base,bstride,vl);
+}
+
+vfloat64m1_t
+test___riscv_vlse64_v_f64m1_mu(vbool64_t mask,vfloat64m1_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m1_mu(mask,merge,base,bstride,vl);
+}
+
+vfloat64m2_t
+test___riscv_vlse64_v_f64m2_mu(vbool32_t mask,vfloat64m2_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m2_mu(mask,merge,base,bstride,vl);
+}
+
+vfloat64m4_t
+test___riscv_vlse64_v_f64m4_mu(vbool16_t mask,vfloat64m4_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m4_mu(mask,merge,base,bstride,vl);
+}
+
+vfloat64m8_t
+test___riscv_vlse64_v_f64m8_mu(vbool8_t mask,vfloat64m8_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m8_mu(mask,merge,base,bstride,vl);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*mu\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_mu-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_mu-2.c
new file mode 100644
index 0000000..bc8727f
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_mu-2.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vlse8_v_i8mf8_mu(vbool64_t mask,vint8mf8_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf8_mu(mask,merge,base,bstride,31);
+}
+
+vint8mf4_t
+test___riscv_vlse8_v_i8mf4_mu(vbool32_t mask,vint8mf4_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf4_mu(mask,merge,base,bstride,31);
+}
+
+vint8mf2_t
+test___riscv_vlse8_v_i8mf2_mu(vbool16_t mask,vint8mf2_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf2_mu(mask,merge,base,bstride,31);
+}
+
+vint8m1_t
+test___riscv_vlse8_v_i8m1_mu(vbool8_t mask,vint8m1_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m1_mu(mask,merge,base,bstride,31);
+}
+
+vint8m2_t
+test___riscv_vlse8_v_i8m2_mu(vbool4_t mask,vint8m2_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m2_mu(mask,merge,base,bstride,31);
+}
+
+vint8m4_t
+test___riscv_vlse8_v_i8m4_mu(vbool2_t mask,vint8m4_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m4_mu(mask,merge,base,bstride,31);
+}
+
+vint8m8_t
+test___riscv_vlse8_v_i8m8_mu(vbool1_t mask,vint8m8_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m8_mu(mask,merge,base,bstride,31);
+}
+
+vuint8mf8_t
+test___riscv_vlse8_v_u8mf8_mu(vbool64_t mask,vuint8mf8_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf8_mu(mask,merge,base,bstride,31);
+}
+
+vuint8mf4_t
+test___riscv_vlse8_v_u8mf4_mu(vbool32_t mask,vuint8mf4_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf4_mu(mask,merge,base,bstride,31);
+}
+
+vuint8mf2_t
+test___riscv_vlse8_v_u8mf2_mu(vbool16_t mask,vuint8mf2_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf2_mu(mask,merge,base,bstride,31);
+}
+
+vuint8m1_t
+test___riscv_vlse8_v_u8m1_mu(vbool8_t mask,vuint8m1_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m1_mu(mask,merge,base,bstride,31);
+}
+
+vuint8m2_t
+test___riscv_vlse8_v_u8m2_mu(vbool4_t mask,vuint8m2_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m2_mu(mask,merge,base,bstride,31);
+}
+
+vuint8m4_t
+test___riscv_vlse8_v_u8m4_mu(vbool2_t mask,vuint8m4_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m4_mu(mask,merge,base,bstride,31);
+}
+
+vuint8m8_t
+test___riscv_vlse8_v_u8m8_mu(vbool1_t mask,vuint8m8_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m8_mu(mask,merge,base,bstride,31);
+}
+
+vint16mf4_t
+test___riscv_vlse16_v_i16mf4_mu(vbool64_t mask,vint16mf4_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf4_mu(mask,merge,base,bstride,31);
+}
+
+vint16mf2_t
+test___riscv_vlse16_v_i16mf2_mu(vbool32_t mask,vint16mf2_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf2_mu(mask,merge,base,bstride,31);
+}
+
+vint16m1_t
+test___riscv_vlse16_v_i16m1_mu(vbool16_t mask,vint16m1_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m1_mu(mask,merge,base,bstride,31);
+}
+
+vint16m2_t
+test___riscv_vlse16_v_i16m2_mu(vbool8_t mask,vint16m2_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m2_mu(mask,merge,base,bstride,31);
+}
+
+vint16m4_t
+test___riscv_vlse16_v_i16m4_mu(vbool4_t mask,vint16m4_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m4_mu(mask,merge,base,bstride,31);
+}
+
+vint16m8_t
+test___riscv_vlse16_v_i16m8_mu(vbool2_t mask,vint16m8_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m8_mu(mask,merge,base,bstride,31);
+}
+
+vuint16mf4_t
+test___riscv_vlse16_v_u16mf4_mu(vbool64_t mask,vuint16mf4_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf4_mu(mask,merge,base,bstride,31);
+}
+
+vuint16mf2_t
+test___riscv_vlse16_v_u16mf2_mu(vbool32_t mask,vuint16mf2_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf2_mu(mask,merge,base,bstride,31);
+}
+
+vuint16m1_t
+test___riscv_vlse16_v_u16m1_mu(vbool16_t mask,vuint16m1_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m1_mu(mask,merge,base,bstride,31);
+}
+
+vuint16m2_t
+test___riscv_vlse16_v_u16m2_mu(vbool8_t mask,vuint16m2_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m2_mu(mask,merge,base,bstride,31);
+}
+
+vuint16m4_t
+test___riscv_vlse16_v_u16m4_mu(vbool4_t mask,vuint16m4_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m4_mu(mask,merge,base,bstride,31);
+}
+
+vuint16m8_t
+test___riscv_vlse16_v_u16m8_mu(vbool2_t mask,vuint16m8_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m8_mu(mask,merge,base,bstride,31);
+}
+
+vint32mf2_t
+test___riscv_vlse32_v_i32mf2_mu(vbool64_t mask,vint32mf2_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32mf2_mu(mask,merge,base,bstride,31);
+}
+
+vint32m1_t
+test___riscv_vlse32_v_i32m1_mu(vbool32_t mask,vint32m1_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m1_mu(mask,merge,base,bstride,31);
+}
+
+vint32m2_t
+test___riscv_vlse32_v_i32m2_mu(vbool16_t mask,vint32m2_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m2_mu(mask,merge,base,bstride,31);
+}
+
+vint32m4_t
+test___riscv_vlse32_v_i32m4_mu(vbool8_t mask,vint32m4_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m4_mu(mask,merge,base,bstride,31);
+}
+
+vint32m8_t
+test___riscv_vlse32_v_i32m8_mu(vbool4_t mask,vint32m8_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m8_mu(mask,merge,base,bstride,31);
+}
+
+vuint32mf2_t
+test___riscv_vlse32_v_u32mf2_mu(vbool64_t mask,vuint32mf2_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32mf2_mu(mask,merge,base,bstride,31);
+}
+
+vuint32m1_t
+test___riscv_vlse32_v_u32m1_mu(vbool32_t mask,vuint32m1_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m1_mu(mask,merge,base,bstride,31);
+}
+
+vuint32m2_t
+test___riscv_vlse32_v_u32m2_mu(vbool16_t mask,vuint32m2_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m2_mu(mask,merge,base,bstride,31);
+}
+
+vuint32m4_t
+test___riscv_vlse32_v_u32m4_mu(vbool8_t mask,vuint32m4_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m4_mu(mask,merge,base,bstride,31);
+}
+
+vuint32m8_t
+test___riscv_vlse32_v_u32m8_mu(vbool4_t mask,vuint32m8_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m8_mu(mask,merge,base,bstride,31);
+}
+
+vfloat32mf2_t
+test___riscv_vlse32_v_f32mf2_mu(vbool64_t mask,vfloat32mf2_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32mf2_mu(mask,merge,base,bstride,31);
+}
+
+vfloat32m1_t
+test___riscv_vlse32_v_f32m1_mu(vbool32_t mask,vfloat32m1_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m1_mu(mask,merge,base,bstride,31);
+}
+
+vfloat32m2_t
+test___riscv_vlse32_v_f32m2_mu(vbool16_t mask,vfloat32m2_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m2_mu(mask,merge,base,bstride,31);
+}
+
+vfloat32m4_t
+test___riscv_vlse32_v_f32m4_mu(vbool8_t mask,vfloat32m4_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m4_mu(mask,merge,base,bstride,31);
+}
+
+vfloat32m8_t
+test___riscv_vlse32_v_f32m8_mu(vbool4_t mask,vfloat32m8_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m8_mu(mask,merge,base,bstride,31);
+}
+
+vint64m1_t
+test___riscv_vlse64_v_i64m1_mu(vbool64_t mask,vint64m1_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m1_mu(mask,merge,base,bstride,31);
+}
+
+vint64m2_t
+test___riscv_vlse64_v_i64m2_mu(vbool32_t mask,vint64m2_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m2_mu(mask,merge,base,bstride,31);
+}
+
+vint64m4_t
+test___riscv_vlse64_v_i64m4_mu(vbool16_t mask,vint64m4_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m4_mu(mask,merge,base,bstride,31);
+}
+
+vint64m8_t
+test___riscv_vlse64_v_i64m8_mu(vbool8_t mask,vint64m8_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m8_mu(mask,merge,base,bstride,31);
+}
+
+vuint64m1_t
+test___riscv_vlse64_v_u64m1_mu(vbool64_t mask,vuint64m1_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m1_mu(mask,merge,base,bstride,31);
+}
+
+vuint64m2_t
+test___riscv_vlse64_v_u64m2_mu(vbool32_t mask,vuint64m2_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m2_mu(mask,merge,base,bstride,31);
+}
+
+vuint64m4_t
+test___riscv_vlse64_v_u64m4_mu(vbool16_t mask,vuint64m4_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m4_mu(mask,merge,base,bstride,31);
+}
+
+vuint64m8_t
+test___riscv_vlse64_v_u64m8_mu(vbool8_t mask,vuint64m8_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m8_mu(mask,merge,base,bstride,31);
+}
+
+vfloat64m1_t
+test___riscv_vlse64_v_f64m1_mu(vbool64_t mask,vfloat64m1_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m1_mu(mask,merge,base,bstride,31);
+}
+
+vfloat64m2_t
+test___riscv_vlse64_v_f64m2_mu(vbool32_t mask,vfloat64m2_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m2_mu(mask,merge,base,bstride,31);
+}
+
+vfloat64m4_t
+test___riscv_vlse64_v_f64m4_mu(vbool16_t mask,vfloat64m4_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m4_mu(mask,merge,base,bstride,31);
+}
+
+vfloat64m8_t
+test___riscv_vlse64_v_f64m8_mu(vbool8_t mask,vfloat64m8_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m8_mu(mask,merge,base,bstride,31);
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*t[au],\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*mu\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*mu\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*mu\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*mu\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*mu\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*mu\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*mu\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*mu\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_mu-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_mu-3.c
new file mode 100644
index 0000000..0e6a486
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_mu-3.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vlse8_v_i8mf8_mu(vbool64_t mask,vint8mf8_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf8_mu(mask,merge,base,bstride,32);
+}
+
+vint8mf4_t
+test___riscv_vlse8_v_i8mf4_mu(vbool32_t mask,vint8mf4_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf4_mu(mask,merge,base,bstride,32);
+}
+
+vint8mf2_t
+test___riscv_vlse8_v_i8mf2_mu(vbool16_t mask,vint8mf2_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf2_mu(mask,merge,base,bstride,32);
+}
+
+vint8m1_t
+test___riscv_vlse8_v_i8m1_mu(vbool8_t mask,vint8m1_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m1_mu(mask,merge,base,bstride,32);
+}
+
+vint8m2_t
+test___riscv_vlse8_v_i8m2_mu(vbool4_t mask,vint8m2_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m2_mu(mask,merge,base,bstride,32);
+}
+
+vint8m4_t
+test___riscv_vlse8_v_i8m4_mu(vbool2_t mask,vint8m4_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m4_mu(mask,merge,base,bstride,32);
+}
+
+vint8m8_t
+test___riscv_vlse8_v_i8m8_mu(vbool1_t mask,vint8m8_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m8_mu(mask,merge,base,bstride,32);
+}
+
+vuint8mf8_t
+test___riscv_vlse8_v_u8mf8_mu(vbool64_t mask,vuint8mf8_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf8_mu(mask,merge,base,bstride,32);
+}
+
+vuint8mf4_t
+test___riscv_vlse8_v_u8mf4_mu(vbool32_t mask,vuint8mf4_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf4_mu(mask,merge,base,bstride,32);
+}
+
+vuint8mf2_t
+test___riscv_vlse8_v_u8mf2_mu(vbool16_t mask,vuint8mf2_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf2_mu(mask,merge,base,bstride,32);
+}
+
+vuint8m1_t
+test___riscv_vlse8_v_u8m1_mu(vbool8_t mask,vuint8m1_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m1_mu(mask,merge,base,bstride,32);
+}
+
+vuint8m2_t
+test___riscv_vlse8_v_u8m2_mu(vbool4_t mask,vuint8m2_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m2_mu(mask,merge,base,bstride,32);
+}
+
+vuint8m4_t
+test___riscv_vlse8_v_u8m4_mu(vbool2_t mask,vuint8m4_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m4_mu(mask,merge,base,bstride,32);
+}
+
+vuint8m8_t
+test___riscv_vlse8_v_u8m8_mu(vbool1_t mask,vuint8m8_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m8_mu(mask,merge,base,bstride,32);
+}
+
+vint16mf4_t
+test___riscv_vlse16_v_i16mf4_mu(vbool64_t mask,vint16mf4_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf4_mu(mask,merge,base,bstride,32);
+}
+
+vint16mf2_t
+test___riscv_vlse16_v_i16mf2_mu(vbool32_t mask,vint16mf2_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf2_mu(mask,merge,base,bstride,32);
+}
+
+vint16m1_t
+test___riscv_vlse16_v_i16m1_mu(vbool16_t mask,vint16m1_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m1_mu(mask,merge,base,bstride,32);
+}
+
+vint16m2_t
+test___riscv_vlse16_v_i16m2_mu(vbool8_t mask,vint16m2_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m2_mu(mask,merge,base,bstride,32);
+}
+
+vint16m4_t
+test___riscv_vlse16_v_i16m4_mu(vbool4_t mask,vint16m4_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m4_mu(mask,merge,base,bstride,32);
+}
+
+vint16m8_t
+test___riscv_vlse16_v_i16m8_mu(vbool2_t mask,vint16m8_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m8_mu(mask,merge,base,bstride,32);
+}
+
+vuint16mf4_t
+test___riscv_vlse16_v_u16mf4_mu(vbool64_t mask,vuint16mf4_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf4_mu(mask,merge,base,bstride,32);
+}
+
+vuint16mf2_t
+test___riscv_vlse16_v_u16mf2_mu(vbool32_t mask,vuint16mf2_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf2_mu(mask,merge,base,bstride,32);
+}
+
+vuint16m1_t
+test___riscv_vlse16_v_u16m1_mu(vbool16_t mask,vuint16m1_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m1_mu(mask,merge,base,bstride,32);
+}
+
+vuint16m2_t
+test___riscv_vlse16_v_u16m2_mu(vbool8_t mask,vuint16m2_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m2_mu(mask,merge,base,bstride,32);
+}
+
+vuint16m4_t
+test___riscv_vlse16_v_u16m4_mu(vbool4_t mask,vuint16m4_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m4_mu(mask,merge,base,bstride,32);
+}
+
+vuint16m8_t
+test___riscv_vlse16_v_u16m8_mu(vbool2_t mask,vuint16m8_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m8_mu(mask,merge,base,bstride,32);
+}
+
+vint32mf2_t
+test___riscv_vlse32_v_i32mf2_mu(vbool64_t mask,vint32mf2_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32mf2_mu(mask,merge,base,bstride,32);
+}
+
+vint32m1_t
+test___riscv_vlse32_v_i32m1_mu(vbool32_t mask,vint32m1_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m1_mu(mask,merge,base,bstride,32);
+}
+
+vint32m2_t
+test___riscv_vlse32_v_i32m2_mu(vbool16_t mask,vint32m2_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m2_mu(mask,merge,base,bstride,32);
+}
+
+vint32m4_t
+test___riscv_vlse32_v_i32m4_mu(vbool8_t mask,vint32m4_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m4_mu(mask,merge,base,bstride,32);
+}
+
+vint32m8_t
+test___riscv_vlse32_v_i32m8_mu(vbool4_t mask,vint32m8_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m8_mu(mask,merge,base,bstride,32);
+}
+
+vuint32mf2_t
+test___riscv_vlse32_v_u32mf2_mu(vbool64_t mask,vuint32mf2_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32mf2_mu(mask,merge,base,bstride,32);
+}
+
+vuint32m1_t
+test___riscv_vlse32_v_u32m1_mu(vbool32_t mask,vuint32m1_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m1_mu(mask,merge,base,bstride,32);
+}
+
+vuint32m2_t
+test___riscv_vlse32_v_u32m2_mu(vbool16_t mask,vuint32m2_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m2_mu(mask,merge,base,bstride,32);
+}
+
+vuint32m4_t
+test___riscv_vlse32_v_u32m4_mu(vbool8_t mask,vuint32m4_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m4_mu(mask,merge,base,bstride,32);
+}
+
+vuint32m8_t
+test___riscv_vlse32_v_u32m8_mu(vbool4_t mask,vuint32m8_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m8_mu(mask,merge,base,bstride,32);
+}
+
+vfloat32mf2_t
+test___riscv_vlse32_v_f32mf2_mu(vbool64_t mask,vfloat32mf2_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32mf2_mu(mask,merge,base,bstride,32);
+}
+
+vfloat32m1_t
+test___riscv_vlse32_v_f32m1_mu(vbool32_t mask,vfloat32m1_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m1_mu(mask,merge,base,bstride,32);
+}
+
+vfloat32m2_t
+test___riscv_vlse32_v_f32m2_mu(vbool16_t mask,vfloat32m2_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m2_mu(mask,merge,base,bstride,32);
+}
+
+vfloat32m4_t
+test___riscv_vlse32_v_f32m4_mu(vbool8_t mask,vfloat32m4_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m4_mu(mask,merge,base,bstride,32);
+}
+
+vfloat32m8_t
+test___riscv_vlse32_v_f32m8_mu(vbool4_t mask,vfloat32m8_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m8_mu(mask,merge,base,bstride,32);
+}
+
+vint64m1_t
+test___riscv_vlse64_v_i64m1_mu(vbool64_t mask,vint64m1_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m1_mu(mask,merge,base,bstride,32);
+}
+
+vint64m2_t
+test___riscv_vlse64_v_i64m2_mu(vbool32_t mask,vint64m2_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m2_mu(mask,merge,base,bstride,32);
+}
+
+vint64m4_t
+test___riscv_vlse64_v_i64m4_mu(vbool16_t mask,vint64m4_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m4_mu(mask,merge,base,bstride,32);
+}
+
+vint64m8_t
+test___riscv_vlse64_v_i64m8_mu(vbool8_t mask,vint64m8_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m8_mu(mask,merge,base,bstride,32);
+}
+
+vuint64m1_t
+test___riscv_vlse64_v_u64m1_mu(vbool64_t mask,vuint64m1_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m1_mu(mask,merge,base,bstride,32);
+}
+
+vuint64m2_t
+test___riscv_vlse64_v_u64m2_mu(vbool32_t mask,vuint64m2_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m2_mu(mask,merge,base,bstride,32);
+}
+
+vuint64m4_t
+test___riscv_vlse64_v_u64m4_mu(vbool16_t mask,vuint64m4_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m4_mu(mask,merge,base,bstride,32);
+}
+
+vuint64m8_t
+test___riscv_vlse64_v_u64m8_mu(vbool8_t mask,vuint64m8_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m8_mu(mask,merge,base,bstride,32);
+}
+
+vfloat64m1_t
+test___riscv_vlse64_v_f64m1_mu(vbool64_t mask,vfloat64m1_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m1_mu(mask,merge,base,bstride,32);
+}
+
+vfloat64m2_t
+test___riscv_vlse64_v_f64m2_mu(vbool32_t mask,vfloat64m2_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m2_mu(mask,merge,base,bstride,32);
+}
+
+vfloat64m4_t
+test___riscv_vlse64_v_f64m4_mu(vbool16_t mask,vfloat64m4_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m4_mu(mask,merge,base,bstride,32);
+}
+
+vfloat64m8_t
+test___riscv_vlse64_v_f64m8_mu(vbool8_t mask,vfloat64m8_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m8_mu(mask,merge,base,bstride,32);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*mu\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_tu-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_tu-1.c
new file mode 100644
index 0000000..32d6876
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_tu-1.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vlse8_v_i8mf8_tu(vint8mf8_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf8_tu(merge,base,bstride,vl);
+}
+
+vint8mf4_t
+test___riscv_vlse8_v_i8mf4_tu(vint8mf4_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf4_tu(merge,base,bstride,vl);
+}
+
+vint8mf2_t
+test___riscv_vlse8_v_i8mf2_tu(vint8mf2_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf2_tu(merge,base,bstride,vl);
+}
+
+vint8m1_t
+test___riscv_vlse8_v_i8m1_tu(vint8m1_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m1_tu(merge,base,bstride,vl);
+}
+
+vint8m2_t
+test___riscv_vlse8_v_i8m2_tu(vint8m2_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m2_tu(merge,base,bstride,vl);
+}
+
+vint8m4_t
+test___riscv_vlse8_v_i8m4_tu(vint8m4_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m4_tu(merge,base,bstride,vl);
+}
+
+vint8m8_t
+test___riscv_vlse8_v_i8m8_tu(vint8m8_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m8_tu(merge,base,bstride,vl);
+}
+
+vuint8mf8_t
+test___riscv_vlse8_v_u8mf8_tu(vuint8mf8_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf8_tu(merge,base,bstride,vl);
+}
+
+vuint8mf4_t
+test___riscv_vlse8_v_u8mf4_tu(vuint8mf4_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf4_tu(merge,base,bstride,vl);
+}
+
+vuint8mf2_t
+test___riscv_vlse8_v_u8mf2_tu(vuint8mf2_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf2_tu(merge,base,bstride,vl);
+}
+
+vuint8m1_t
+test___riscv_vlse8_v_u8m1_tu(vuint8m1_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m1_tu(merge,base,bstride,vl);
+}
+
+vuint8m2_t
+test___riscv_vlse8_v_u8m2_tu(vuint8m2_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m2_tu(merge,base,bstride,vl);
+}
+
+vuint8m4_t
+test___riscv_vlse8_v_u8m4_tu(vuint8m4_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m4_tu(merge,base,bstride,vl);
+}
+
+vuint8m8_t
+test___riscv_vlse8_v_u8m8_tu(vuint8m8_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m8_tu(merge,base,bstride,vl);
+}
+
+vint16mf4_t
+test___riscv_vlse16_v_i16mf4_tu(vint16mf4_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf4_tu(merge,base,bstride,vl);
+}
+
+vint16mf2_t
+test___riscv_vlse16_v_i16mf2_tu(vint16mf2_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf2_tu(merge,base,bstride,vl);
+}
+
+vint16m1_t
+test___riscv_vlse16_v_i16m1_tu(vint16m1_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m1_tu(merge,base,bstride,vl);
+}
+
+vint16m2_t
+test___riscv_vlse16_v_i16m2_tu(vint16m2_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m2_tu(merge,base,bstride,vl);
+}
+
+vint16m4_t
+test___riscv_vlse16_v_i16m4_tu(vint16m4_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m4_tu(merge,base,bstride,vl);
+}
+
+vint16m8_t
+test___riscv_vlse16_v_i16m8_tu(vint16m8_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m8_tu(merge,base,bstride,vl);
+}
+
+vuint16mf4_t
+test___riscv_vlse16_v_u16mf4_tu(vuint16mf4_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf4_tu(merge,base,bstride,vl);
+}
+
+vuint16mf2_t
+test___riscv_vlse16_v_u16mf2_tu(vuint16mf2_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf2_tu(merge,base,bstride,vl);
+}
+
+vuint16m1_t
+test___riscv_vlse16_v_u16m1_tu(vuint16m1_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m1_tu(merge,base,bstride,vl);
+}
+
+vuint16m2_t
+test___riscv_vlse16_v_u16m2_tu(vuint16m2_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m2_tu(merge,base,bstride,vl);
+}
+
+vuint16m4_t
+test___riscv_vlse16_v_u16m4_tu(vuint16m4_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m4_tu(merge,base,bstride,vl);
+}
+
+vuint16m8_t
+test___riscv_vlse16_v_u16m8_tu(vuint16m8_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m8_tu(merge,base,bstride,vl);
+}
+
+vint32mf2_t
+test___riscv_vlse32_v_i32mf2_tu(vint32mf2_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32mf2_tu(merge,base,bstride,vl);
+}
+
+vint32m1_t
+test___riscv_vlse32_v_i32m1_tu(vint32m1_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m1_tu(merge,base,bstride,vl);
+}
+
+vint32m2_t
+test___riscv_vlse32_v_i32m2_tu(vint32m2_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m2_tu(merge,base,bstride,vl);
+}
+
+vint32m4_t
+test___riscv_vlse32_v_i32m4_tu(vint32m4_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m4_tu(merge,base,bstride,vl);
+}
+
+vint32m8_t
+test___riscv_vlse32_v_i32m8_tu(vint32m8_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m8_tu(merge,base,bstride,vl);
+}
+
+vuint32mf2_t
+test___riscv_vlse32_v_u32mf2_tu(vuint32mf2_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32mf2_tu(merge,base,bstride,vl);
+}
+
+vuint32m1_t
+test___riscv_vlse32_v_u32m1_tu(vuint32m1_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m1_tu(merge,base,bstride,vl);
+}
+
+vuint32m2_t
+test___riscv_vlse32_v_u32m2_tu(vuint32m2_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m2_tu(merge,base,bstride,vl);
+}
+
+vuint32m4_t
+test___riscv_vlse32_v_u32m4_tu(vuint32m4_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m4_tu(merge,base,bstride,vl);
+}
+
+vuint32m8_t
+test___riscv_vlse32_v_u32m8_tu(vuint32m8_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m8_tu(merge,base,bstride,vl);
+}
+
+vfloat32mf2_t
+test___riscv_vlse32_v_f32mf2_tu(vfloat32mf2_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32mf2_tu(merge,base,bstride,vl);
+}
+
+vfloat32m1_t
+test___riscv_vlse32_v_f32m1_tu(vfloat32m1_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m1_tu(merge,base,bstride,vl);
+}
+
+vfloat32m2_t
+test___riscv_vlse32_v_f32m2_tu(vfloat32m2_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m2_tu(merge,base,bstride,vl);
+}
+
+vfloat32m4_t
+test___riscv_vlse32_v_f32m4_tu(vfloat32m4_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m4_tu(merge,base,bstride,vl);
+}
+
+vfloat32m8_t
+test___riscv_vlse32_v_f32m8_tu(vfloat32m8_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m8_tu(merge,base,bstride,vl);
+}
+
+vint64m1_t
+test___riscv_vlse64_v_i64m1_tu(vint64m1_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m1_tu(merge,base,bstride,vl);
+}
+
+vint64m2_t
+test___riscv_vlse64_v_i64m2_tu(vint64m2_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m2_tu(merge,base,bstride,vl);
+}
+
+vint64m4_t
+test___riscv_vlse64_v_i64m4_tu(vint64m4_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m4_tu(merge,base,bstride,vl);
+}
+
+vint64m8_t
+test___riscv_vlse64_v_i64m8_tu(vint64m8_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m8_tu(merge,base,bstride,vl);
+}
+
+vuint64m1_t
+test___riscv_vlse64_v_u64m1_tu(vuint64m1_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m1_tu(merge,base,bstride,vl);
+}
+
+vuint64m2_t
+test___riscv_vlse64_v_u64m2_tu(vuint64m2_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m2_tu(merge,base,bstride,vl);
+}
+
+vuint64m4_t
+test___riscv_vlse64_v_u64m4_tu(vuint64m4_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m4_tu(merge,base,bstride,vl);
+}
+
+vuint64m8_t
+test___riscv_vlse64_v_u64m8_tu(vuint64m8_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m8_tu(merge,base,bstride,vl);
+}
+
+vfloat64m1_t
+test___riscv_vlse64_v_f64m1_tu(vfloat64m1_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m1_tu(merge,base,bstride,vl);
+}
+
+vfloat64m2_t
+test___riscv_vlse64_v_f64m2_tu(vfloat64m2_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m2_tu(merge,base,bstride,vl);
+}
+
+vfloat64m4_t
+test___riscv_vlse64_v_f64m4_tu(vfloat64m4_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m4_tu(merge,base,bstride,vl);
+}
+
+vfloat64m8_t
+test___riscv_vlse64_v_f64m8_tu(vfloat64m8_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m8_tu(merge,base,bstride,vl);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_tu-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_tu-2.c
new file mode 100644
index 0000000..7057584
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_tu-2.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vlse8_v_i8mf8_tu(vint8mf8_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf8_tu(merge,base,bstride,31);
+}
+
+vint8mf4_t
+test___riscv_vlse8_v_i8mf4_tu(vint8mf4_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf4_tu(merge,base,bstride,31);
+}
+
+vint8mf2_t
+test___riscv_vlse8_v_i8mf2_tu(vint8mf2_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf2_tu(merge,base,bstride,31);
+}
+
+vint8m1_t
+test___riscv_vlse8_v_i8m1_tu(vint8m1_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m1_tu(merge,base,bstride,31);
+}
+
+vint8m2_t
+test___riscv_vlse8_v_i8m2_tu(vint8m2_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m2_tu(merge,base,bstride,31);
+}
+
+vint8m4_t
+test___riscv_vlse8_v_i8m4_tu(vint8m4_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m4_tu(merge,base,bstride,31);
+}
+
+vint8m8_t
+test___riscv_vlse8_v_i8m8_tu(vint8m8_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m8_tu(merge,base,bstride,31);
+}
+
+vuint8mf8_t
+test___riscv_vlse8_v_u8mf8_tu(vuint8mf8_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf8_tu(merge,base,bstride,31);
+}
+
+vuint8mf4_t
+test___riscv_vlse8_v_u8mf4_tu(vuint8mf4_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf4_tu(merge,base,bstride,31);
+}
+
+vuint8mf2_t
+test___riscv_vlse8_v_u8mf2_tu(vuint8mf2_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf2_tu(merge,base,bstride,31);
+}
+
+vuint8m1_t
+test___riscv_vlse8_v_u8m1_tu(vuint8m1_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m1_tu(merge,base,bstride,31);
+}
+
+vuint8m2_t
+test___riscv_vlse8_v_u8m2_tu(vuint8m2_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m2_tu(merge,base,bstride,31);
+}
+
+vuint8m4_t
+test___riscv_vlse8_v_u8m4_tu(vuint8m4_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m4_tu(merge,base,bstride,31);
+}
+
+vuint8m8_t
+test___riscv_vlse8_v_u8m8_tu(vuint8m8_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m8_tu(merge,base,bstride,31);
+}
+
+vint16mf4_t
+test___riscv_vlse16_v_i16mf4_tu(vint16mf4_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf4_tu(merge,base,bstride,31);
+}
+
+vint16mf2_t
+test___riscv_vlse16_v_i16mf2_tu(vint16mf2_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf2_tu(merge,base,bstride,31);
+}
+
+vint16m1_t
+test___riscv_vlse16_v_i16m1_tu(vint16m1_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m1_tu(merge,base,bstride,31);
+}
+
+vint16m2_t
+test___riscv_vlse16_v_i16m2_tu(vint16m2_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m2_tu(merge,base,bstride,31);
+}
+
+vint16m4_t
+test___riscv_vlse16_v_i16m4_tu(vint16m4_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m4_tu(merge,base,bstride,31);
+}
+
+vint16m8_t
+test___riscv_vlse16_v_i16m8_tu(vint16m8_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m8_tu(merge,base,bstride,31);
+}
+
+vuint16mf4_t
+test___riscv_vlse16_v_u16mf4_tu(vuint16mf4_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf4_tu(merge,base,bstride,31);
+}
+
+vuint16mf2_t
+test___riscv_vlse16_v_u16mf2_tu(vuint16mf2_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf2_tu(merge,base,bstride,31);
+}
+
+vuint16m1_t
+test___riscv_vlse16_v_u16m1_tu(vuint16m1_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m1_tu(merge,base,bstride,31);
+}
+
+vuint16m2_t
+test___riscv_vlse16_v_u16m2_tu(vuint16m2_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m2_tu(merge,base,bstride,31);
+}
+
+vuint16m4_t
+test___riscv_vlse16_v_u16m4_tu(vuint16m4_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m4_tu(merge,base,bstride,31);
+}
+
+vuint16m8_t
+test___riscv_vlse16_v_u16m8_tu(vuint16m8_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m8_tu(merge,base,bstride,31);
+}
+
+vint32mf2_t
+test___riscv_vlse32_v_i32mf2_tu(vint32mf2_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32mf2_tu(merge,base,bstride,31);
+}
+
+vint32m1_t
+test___riscv_vlse32_v_i32m1_tu(vint32m1_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m1_tu(merge,base,bstride,31);
+}
+
+vint32m2_t
+test___riscv_vlse32_v_i32m2_tu(vint32m2_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m2_tu(merge,base,bstride,31);
+}
+
+vint32m4_t
+test___riscv_vlse32_v_i32m4_tu(vint32m4_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m4_tu(merge,base,bstride,31);
+}
+
+vint32m8_t
+test___riscv_vlse32_v_i32m8_tu(vint32m8_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m8_tu(merge,base,bstride,31);
+}
+
+vuint32mf2_t
+test___riscv_vlse32_v_u32mf2_tu(vuint32mf2_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32mf2_tu(merge,base,bstride,31);
+}
+
+vuint32m1_t
+test___riscv_vlse32_v_u32m1_tu(vuint32m1_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m1_tu(merge,base,bstride,31);
+}
+
+vuint32m2_t
+test___riscv_vlse32_v_u32m2_tu(vuint32m2_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m2_tu(merge,base,bstride,31);
+}
+
+vuint32m4_t
+test___riscv_vlse32_v_u32m4_tu(vuint32m4_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m4_tu(merge,base,bstride,31);
+}
+
+vuint32m8_t
+test___riscv_vlse32_v_u32m8_tu(vuint32m8_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m8_tu(merge,base,bstride,31);
+}
+
+vfloat32mf2_t
+test___riscv_vlse32_v_f32mf2_tu(vfloat32mf2_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32mf2_tu(merge,base,bstride,31);
+}
+
+vfloat32m1_t
+test___riscv_vlse32_v_f32m1_tu(vfloat32m1_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m1_tu(merge,base,bstride,31);
+}
+
+vfloat32m2_t
+test___riscv_vlse32_v_f32m2_tu(vfloat32m2_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m2_tu(merge,base,bstride,31);
+}
+
+vfloat32m4_t
+test___riscv_vlse32_v_f32m4_tu(vfloat32m4_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m4_tu(merge,base,bstride,31);
+}
+
+vfloat32m8_t
+test___riscv_vlse32_v_f32m8_tu(vfloat32m8_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m8_tu(merge,base,bstride,31);
+}
+
+vint64m1_t
+test___riscv_vlse64_v_i64m1_tu(vint64m1_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m1_tu(merge,base,bstride,31);
+}
+
+vint64m2_t
+test___riscv_vlse64_v_i64m2_tu(vint64m2_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m2_tu(merge,base,bstride,31);
+}
+
+vint64m4_t
+test___riscv_vlse64_v_i64m4_tu(vint64m4_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m4_tu(merge,base,bstride,31);
+}
+
+vint64m8_t
+test___riscv_vlse64_v_i64m8_tu(vint64m8_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m8_tu(merge,base,bstride,31);
+}
+
+vuint64m1_t
+test___riscv_vlse64_v_u64m1_tu(vuint64m1_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m1_tu(merge,base,bstride,31);
+}
+
+vuint64m2_t
+test___riscv_vlse64_v_u64m2_tu(vuint64m2_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m2_tu(merge,base,bstride,31);
+}
+
+vuint64m4_t
+test___riscv_vlse64_v_u64m4_tu(vuint64m4_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m4_tu(merge,base,bstride,31);
+}
+
+vuint64m8_t
+test___riscv_vlse64_v_u64m8_tu(vuint64m8_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m8_tu(merge,base,bstride,31);
+}
+
+vfloat64m1_t
+test___riscv_vlse64_v_f64m1_tu(vfloat64m1_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m1_tu(merge,base,bstride,31);
+}
+
+vfloat64m2_t
+test___riscv_vlse64_v_f64m2_tu(vfloat64m2_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m2_tu(merge,base,bstride,31);
+}
+
+vfloat64m4_t
+test___riscv_vlse64_v_f64m4_tu(vfloat64m4_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m4_tu(merge,base,bstride,31);
+}
+
+vfloat64m8_t
+test___riscv_vlse64_v_f64m8_tu(vfloat64m8_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m8_tu(merge,base,bstride,31);
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_tu-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_tu-3.c
new file mode 100644
index 0000000..c9a3c4b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_tu-3.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vlse8_v_i8mf8_tu(vint8mf8_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf8_tu(merge,base,bstride,32);
+}
+
+vint8mf4_t
+test___riscv_vlse8_v_i8mf4_tu(vint8mf4_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf4_tu(merge,base,bstride,32);
+}
+
+vint8mf2_t
+test___riscv_vlse8_v_i8mf2_tu(vint8mf2_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf2_tu(merge,base,bstride,32);
+}
+
+vint8m1_t
+test___riscv_vlse8_v_i8m1_tu(vint8m1_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m1_tu(merge,base,bstride,32);
+}
+
+vint8m2_t
+test___riscv_vlse8_v_i8m2_tu(vint8m2_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m2_tu(merge,base,bstride,32);
+}
+
+vint8m4_t
+test___riscv_vlse8_v_i8m4_tu(vint8m4_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m4_tu(merge,base,bstride,32);
+}
+
+vint8m8_t
+test___riscv_vlse8_v_i8m8_tu(vint8m8_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m8_tu(merge,base,bstride,32);
+}
+
+vuint8mf8_t
+test___riscv_vlse8_v_u8mf8_tu(vuint8mf8_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf8_tu(merge,base,bstride,32);
+}
+
+vuint8mf4_t
+test___riscv_vlse8_v_u8mf4_tu(vuint8mf4_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf4_tu(merge,base,bstride,32);
+}
+
+vuint8mf2_t
+test___riscv_vlse8_v_u8mf2_tu(vuint8mf2_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf2_tu(merge,base,bstride,32);
+}
+
+vuint8m1_t
+test___riscv_vlse8_v_u8m1_tu(vuint8m1_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m1_tu(merge,base,bstride,32);
+}
+
+vuint8m2_t
+test___riscv_vlse8_v_u8m2_tu(vuint8m2_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m2_tu(merge,base,bstride,32);
+}
+
+vuint8m4_t
+test___riscv_vlse8_v_u8m4_tu(vuint8m4_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m4_tu(merge,base,bstride,32);
+}
+
+vuint8m8_t
+test___riscv_vlse8_v_u8m8_tu(vuint8m8_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m8_tu(merge,base,bstride,32);
+}
+
+vint16mf4_t
+test___riscv_vlse16_v_i16mf4_tu(vint16mf4_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf4_tu(merge,base,bstride,32);
+}
+
+vint16mf2_t
+test___riscv_vlse16_v_i16mf2_tu(vint16mf2_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf2_tu(merge,base,bstride,32);
+}
+
+vint16m1_t
+test___riscv_vlse16_v_i16m1_tu(vint16m1_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m1_tu(merge,base,bstride,32);
+}
+
+vint16m2_t
+test___riscv_vlse16_v_i16m2_tu(vint16m2_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m2_tu(merge,base,bstride,32);
+}
+
+vint16m4_t
+test___riscv_vlse16_v_i16m4_tu(vint16m4_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m4_tu(merge,base,bstride,32);
+}
+
+vint16m8_t
+test___riscv_vlse16_v_i16m8_tu(vint16m8_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m8_tu(merge,base,bstride,32);
+}
+
+vuint16mf4_t
+test___riscv_vlse16_v_u16mf4_tu(vuint16mf4_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf4_tu(merge,base,bstride,32);
+}
+
+vuint16mf2_t
+test___riscv_vlse16_v_u16mf2_tu(vuint16mf2_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf2_tu(merge,base,bstride,32);
+}
+
+vuint16m1_t
+test___riscv_vlse16_v_u16m1_tu(vuint16m1_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m1_tu(merge,base,bstride,32);
+}
+
+vuint16m2_t
+test___riscv_vlse16_v_u16m2_tu(vuint16m2_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m2_tu(merge,base,bstride,32);
+}
+
+vuint16m4_t
+test___riscv_vlse16_v_u16m4_tu(vuint16m4_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m4_tu(merge,base,bstride,32);
+}
+
+vuint16m8_t
+test___riscv_vlse16_v_u16m8_tu(vuint16m8_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m8_tu(merge,base,bstride,32);
+}
+
+vint32mf2_t
+test___riscv_vlse32_v_i32mf2_tu(vint32mf2_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32mf2_tu(merge,base,bstride,32);
+}
+
+vint32m1_t
+test___riscv_vlse32_v_i32m1_tu(vint32m1_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m1_tu(merge,base,bstride,32);
+}
+
+vint32m2_t
+test___riscv_vlse32_v_i32m2_tu(vint32m2_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m2_tu(merge,base,bstride,32);
+}
+
+vint32m4_t
+test___riscv_vlse32_v_i32m4_tu(vint32m4_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m4_tu(merge,base,bstride,32);
+}
+
+vint32m8_t
+test___riscv_vlse32_v_i32m8_tu(vint32m8_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m8_tu(merge,base,bstride,32);
+}
+
+vuint32mf2_t
+test___riscv_vlse32_v_u32mf2_tu(vuint32mf2_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32mf2_tu(merge,base,bstride,32);
+}
+
+vuint32m1_t
+test___riscv_vlse32_v_u32m1_tu(vuint32m1_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m1_tu(merge,base,bstride,32);
+}
+
+vuint32m2_t
+test___riscv_vlse32_v_u32m2_tu(vuint32m2_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m2_tu(merge,base,bstride,32);
+}
+
+vuint32m4_t
+test___riscv_vlse32_v_u32m4_tu(vuint32m4_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m4_tu(merge,base,bstride,32);
+}
+
+vuint32m8_t
+test___riscv_vlse32_v_u32m8_tu(vuint32m8_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m8_tu(merge,base,bstride,32);
+}
+
+vfloat32mf2_t
+test___riscv_vlse32_v_f32mf2_tu(vfloat32mf2_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32mf2_tu(merge,base,bstride,32);
+}
+
+vfloat32m1_t
+test___riscv_vlse32_v_f32m1_tu(vfloat32m1_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m1_tu(merge,base,bstride,32);
+}
+
+vfloat32m2_t
+test___riscv_vlse32_v_f32m2_tu(vfloat32m2_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m2_tu(merge,base,bstride,32);
+}
+
+vfloat32m4_t
+test___riscv_vlse32_v_f32m4_tu(vfloat32m4_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m4_tu(merge,base,bstride,32);
+}
+
+vfloat32m8_t
+test___riscv_vlse32_v_f32m8_tu(vfloat32m8_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m8_tu(merge,base,bstride,32);
+}
+
+vint64m1_t
+test___riscv_vlse64_v_i64m1_tu(vint64m1_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m1_tu(merge,base,bstride,32);
+}
+
+vint64m2_t
+test___riscv_vlse64_v_i64m2_tu(vint64m2_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m2_tu(merge,base,bstride,32);
+}
+
+vint64m4_t
+test___riscv_vlse64_v_i64m4_tu(vint64m4_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m4_tu(merge,base,bstride,32);
+}
+
+vint64m8_t
+test___riscv_vlse64_v_i64m8_tu(vint64m8_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m8_tu(merge,base,bstride,32);
+}
+
+vuint64m1_t
+test___riscv_vlse64_v_u64m1_tu(vuint64m1_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m1_tu(merge,base,bstride,32);
+}
+
+vuint64m2_t
+test___riscv_vlse64_v_u64m2_tu(vuint64m2_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m2_tu(merge,base,bstride,32);
+}
+
+vuint64m4_t
+test___riscv_vlse64_v_u64m4_tu(vuint64m4_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m4_tu(merge,base,bstride,32);
+}
+
+vuint64m8_t
+test___riscv_vlse64_v_u64m8_tu(vuint64m8_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m8_tu(merge,base,bstride,32);
+}
+
+vfloat64m1_t
+test___riscv_vlse64_v_f64m1_tu(vfloat64m1_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m1_tu(merge,base,bstride,32);
+}
+
+vfloat64m2_t
+test___riscv_vlse64_v_f64m2_tu(vfloat64m2_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m2_tu(merge,base,bstride,32);
+}
+
+vfloat64m4_t
+test___riscv_vlse64_v_f64m4_tu(vfloat64m4_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m4_tu(merge,base,bstride,32);
+}
+
+vfloat64m8_t
+test___riscv_vlse64_v_f64m8_tu(vfloat64m8_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m8_tu(merge,base,bstride,32);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*[a-x0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_tum-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_tum-1.c
new file mode 100644
index 0000000..b812709
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_tum-1.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vlse8_v_i8mf8_tum(vbool64_t mask,vint8mf8_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf8_tum(mask,merge,base,bstride,vl);
+}
+
+vint8mf4_t
+test___riscv_vlse8_v_i8mf4_tum(vbool32_t mask,vint8mf4_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf4_tum(mask,merge,base,bstride,vl);
+}
+
+vint8mf2_t
+test___riscv_vlse8_v_i8mf2_tum(vbool16_t mask,vint8mf2_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf2_tum(mask,merge,base,bstride,vl);
+}
+
+vint8m1_t
+test___riscv_vlse8_v_i8m1_tum(vbool8_t mask,vint8m1_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m1_tum(mask,merge,base,bstride,vl);
+}
+
+vint8m2_t
+test___riscv_vlse8_v_i8m2_tum(vbool4_t mask,vint8m2_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m2_tum(mask,merge,base,bstride,vl);
+}
+
+vint8m4_t
+test___riscv_vlse8_v_i8m4_tum(vbool2_t mask,vint8m4_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m4_tum(mask,merge,base,bstride,vl);
+}
+
+vint8m8_t
+test___riscv_vlse8_v_i8m8_tum(vbool1_t mask,vint8m8_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m8_tum(mask,merge,base,bstride,vl);
+}
+
+vuint8mf8_t
+test___riscv_vlse8_v_u8mf8_tum(vbool64_t mask,vuint8mf8_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf8_tum(mask,merge,base,bstride,vl);
+}
+
+vuint8mf4_t
+test___riscv_vlse8_v_u8mf4_tum(vbool32_t mask,vuint8mf4_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf4_tum(mask,merge,base,bstride,vl);
+}
+
+vuint8mf2_t
+test___riscv_vlse8_v_u8mf2_tum(vbool16_t mask,vuint8mf2_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf2_tum(mask,merge,base,bstride,vl);
+}
+
+vuint8m1_t
+test___riscv_vlse8_v_u8m1_tum(vbool8_t mask,vuint8m1_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m1_tum(mask,merge,base,bstride,vl);
+}
+
+vuint8m2_t
+test___riscv_vlse8_v_u8m2_tum(vbool4_t mask,vuint8m2_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m2_tum(mask,merge,base,bstride,vl);
+}
+
+vuint8m4_t
+test___riscv_vlse8_v_u8m4_tum(vbool2_t mask,vuint8m4_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m4_tum(mask,merge,base,bstride,vl);
+}
+
+vuint8m8_t
+test___riscv_vlse8_v_u8m8_tum(vbool1_t mask,vuint8m8_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m8_tum(mask,merge,base,bstride,vl);
+}
+
+vint16mf4_t
+test___riscv_vlse16_v_i16mf4_tum(vbool64_t mask,vint16mf4_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf4_tum(mask,merge,base,bstride,vl);
+}
+
+vint16mf2_t
+test___riscv_vlse16_v_i16mf2_tum(vbool32_t mask,vint16mf2_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf2_tum(mask,merge,base,bstride,vl);
+}
+
+vint16m1_t
+test___riscv_vlse16_v_i16m1_tum(vbool16_t mask,vint16m1_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m1_tum(mask,merge,base,bstride,vl);
+}
+
+vint16m2_t
+test___riscv_vlse16_v_i16m2_tum(vbool8_t mask,vint16m2_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m2_tum(mask,merge,base,bstride,vl);
+}
+
+vint16m4_t
+test___riscv_vlse16_v_i16m4_tum(vbool4_t mask,vint16m4_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m4_tum(mask,merge,base,bstride,vl);
+}
+
+vint16m8_t
+test___riscv_vlse16_v_i16m8_tum(vbool2_t mask,vint16m8_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m8_tum(mask,merge,base,bstride,vl);
+}
+
+vuint16mf4_t
+test___riscv_vlse16_v_u16mf4_tum(vbool64_t mask,vuint16mf4_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf4_tum(mask,merge,base,bstride,vl);
+}
+
+vuint16mf2_t
+test___riscv_vlse16_v_u16mf2_tum(vbool32_t mask,vuint16mf2_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf2_tum(mask,merge,base,bstride,vl);
+}
+
+vuint16m1_t
+test___riscv_vlse16_v_u16m1_tum(vbool16_t mask,vuint16m1_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m1_tum(mask,merge,base,bstride,vl);
+}
+
+vuint16m2_t
+test___riscv_vlse16_v_u16m2_tum(vbool8_t mask,vuint16m2_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m2_tum(mask,merge,base,bstride,vl);
+}
+
+vuint16m4_t
+test___riscv_vlse16_v_u16m4_tum(vbool4_t mask,vuint16m4_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m4_tum(mask,merge,base,bstride,vl);
+}
+
+vuint16m8_t
+test___riscv_vlse16_v_u16m8_tum(vbool2_t mask,vuint16m8_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m8_tum(mask,merge,base,bstride,vl);
+}
+
+vint32mf2_t
+test___riscv_vlse32_v_i32mf2_tum(vbool64_t mask,vint32mf2_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32mf2_tum(mask,merge,base,bstride,vl);
+}
+
+vint32m1_t
+test___riscv_vlse32_v_i32m1_tum(vbool32_t mask,vint32m1_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m1_tum(mask,merge,base,bstride,vl);
+}
+
+vint32m2_t
+test___riscv_vlse32_v_i32m2_tum(vbool16_t mask,vint32m2_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m2_tum(mask,merge,base,bstride,vl);
+}
+
+vint32m4_t
+test___riscv_vlse32_v_i32m4_tum(vbool8_t mask,vint32m4_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m4_tum(mask,merge,base,bstride,vl);
+}
+
+vint32m8_t
+test___riscv_vlse32_v_i32m8_tum(vbool4_t mask,vint32m8_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m8_tum(mask,merge,base,bstride,vl);
+}
+
+vuint32mf2_t
+test___riscv_vlse32_v_u32mf2_tum(vbool64_t mask,vuint32mf2_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32mf2_tum(mask,merge,base,bstride,vl);
+}
+
+vuint32m1_t
+test___riscv_vlse32_v_u32m1_tum(vbool32_t mask,vuint32m1_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m1_tum(mask,merge,base,bstride,vl);
+}
+
+vuint32m2_t
+test___riscv_vlse32_v_u32m2_tum(vbool16_t mask,vuint32m2_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m2_tum(mask,merge,base,bstride,vl);
+}
+
+vuint32m4_t
+test___riscv_vlse32_v_u32m4_tum(vbool8_t mask,vuint32m4_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m4_tum(mask,merge,base,bstride,vl);
+}
+
+vuint32m8_t
+test___riscv_vlse32_v_u32m8_tum(vbool4_t mask,vuint32m8_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m8_tum(mask,merge,base,bstride,vl);
+}
+
+vfloat32mf2_t
+test___riscv_vlse32_v_f32mf2_tum(vbool64_t mask,vfloat32mf2_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32mf2_tum(mask,merge,base,bstride,vl);
+}
+
+vfloat32m1_t
+test___riscv_vlse32_v_f32m1_tum(vbool32_t mask,vfloat32m1_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m1_tum(mask,merge,base,bstride,vl);
+}
+
+vfloat32m2_t
+test___riscv_vlse32_v_f32m2_tum(vbool16_t mask,vfloat32m2_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m2_tum(mask,merge,base,bstride,vl);
+}
+
+vfloat32m4_t
+test___riscv_vlse32_v_f32m4_tum(vbool8_t mask,vfloat32m4_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m4_tum(mask,merge,base,bstride,vl);
+}
+
+vfloat32m8_t
+test___riscv_vlse32_v_f32m8_tum(vbool4_t mask,vfloat32m8_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m8_tum(mask,merge,base,bstride,vl);
+}
+
+vint64m1_t
+test___riscv_vlse64_v_i64m1_tum(vbool64_t mask,vint64m1_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m1_tum(mask,merge,base,bstride,vl);
+}
+
+vint64m2_t
+test___riscv_vlse64_v_i64m2_tum(vbool32_t mask,vint64m2_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m2_tum(mask,merge,base,bstride,vl);
+}
+
+vint64m4_t
+test___riscv_vlse64_v_i64m4_tum(vbool16_t mask,vint64m4_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m4_tum(mask,merge,base,bstride,vl);
+}
+
+vint64m8_t
+test___riscv_vlse64_v_i64m8_tum(vbool8_t mask,vint64m8_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m8_tum(mask,merge,base,bstride,vl);
+}
+
+vuint64m1_t
+test___riscv_vlse64_v_u64m1_tum(vbool64_t mask,vuint64m1_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m1_tum(mask,merge,base,bstride,vl);
+}
+
+vuint64m2_t
+test___riscv_vlse64_v_u64m2_tum(vbool32_t mask,vuint64m2_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m2_tum(mask,merge,base,bstride,vl);
+}
+
+vuint64m4_t
+test___riscv_vlse64_v_u64m4_tum(vbool16_t mask,vuint64m4_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m4_tum(mask,merge,base,bstride,vl);
+}
+
+vuint64m8_t
+test___riscv_vlse64_v_u64m8_tum(vbool8_t mask,vuint64m8_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m8_tum(mask,merge,base,bstride,vl);
+}
+
+vfloat64m1_t
+test___riscv_vlse64_v_f64m1_tum(vbool64_t mask,vfloat64m1_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m1_tum(mask,merge,base,bstride,vl);
+}
+
+vfloat64m2_t
+test___riscv_vlse64_v_f64m2_tum(vbool32_t mask,vfloat64m2_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m2_tum(mask,merge,base,bstride,vl);
+}
+
+vfloat64m4_t
+test___riscv_vlse64_v_f64m4_tum(vbool16_t mask,vfloat64m4_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m4_tum(mask,merge,base,bstride,vl);
+}
+
+vfloat64m8_t
+test___riscv_vlse64_v_f64m8_tum(vbool8_t mask,vfloat64m8_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m8_tum(mask,merge,base,bstride,vl);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_tum-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_tum-2.c
new file mode 100644
index 0000000..0bf7400
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_tum-2.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vlse8_v_i8mf8_tum(vbool64_t mask,vint8mf8_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf8_tum(mask,merge,base,bstride,31);
+}
+
+vint8mf4_t
+test___riscv_vlse8_v_i8mf4_tum(vbool32_t mask,vint8mf4_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf4_tum(mask,merge,base,bstride,31);
+}
+
+vint8mf2_t
+test___riscv_vlse8_v_i8mf2_tum(vbool16_t mask,vint8mf2_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf2_tum(mask,merge,base,bstride,31);
+}
+
+vint8m1_t
+test___riscv_vlse8_v_i8m1_tum(vbool8_t mask,vint8m1_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m1_tum(mask,merge,base,bstride,31);
+}
+
+vint8m2_t
+test___riscv_vlse8_v_i8m2_tum(vbool4_t mask,vint8m2_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m2_tum(mask,merge,base,bstride,31);
+}
+
+vint8m4_t
+test___riscv_vlse8_v_i8m4_tum(vbool2_t mask,vint8m4_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m4_tum(mask,merge,base,bstride,31);
+}
+
+vint8m8_t
+test___riscv_vlse8_v_i8m8_tum(vbool1_t mask,vint8m8_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m8_tum(mask,merge,base,bstride,31);
+}
+
+vuint8mf8_t
+test___riscv_vlse8_v_u8mf8_tum(vbool64_t mask,vuint8mf8_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf8_tum(mask,merge,base,bstride,31);
+}
+
+vuint8mf4_t
+test___riscv_vlse8_v_u8mf4_tum(vbool32_t mask,vuint8mf4_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf4_tum(mask,merge,base,bstride,31);
+}
+
+vuint8mf2_t
+test___riscv_vlse8_v_u8mf2_tum(vbool16_t mask,vuint8mf2_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf2_tum(mask,merge,base,bstride,31);
+}
+
+vuint8m1_t
+test___riscv_vlse8_v_u8m1_tum(vbool8_t mask,vuint8m1_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m1_tum(mask,merge,base,bstride,31);
+}
+
+vuint8m2_t
+test___riscv_vlse8_v_u8m2_tum(vbool4_t mask,vuint8m2_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m2_tum(mask,merge,base,bstride,31);
+}
+
+vuint8m4_t
+test___riscv_vlse8_v_u8m4_tum(vbool2_t mask,vuint8m4_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m4_tum(mask,merge,base,bstride,31);
+}
+
+vuint8m8_t
+test___riscv_vlse8_v_u8m8_tum(vbool1_t mask,vuint8m8_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m8_tum(mask,merge,base,bstride,31);
+}
+
+vint16mf4_t
+test___riscv_vlse16_v_i16mf4_tum(vbool64_t mask,vint16mf4_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf4_tum(mask,merge,base,bstride,31);
+}
+
+vint16mf2_t
+test___riscv_vlse16_v_i16mf2_tum(vbool32_t mask,vint16mf2_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf2_tum(mask,merge,base,bstride,31);
+}
+
+vint16m1_t
+test___riscv_vlse16_v_i16m1_tum(vbool16_t mask,vint16m1_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m1_tum(mask,merge,base,bstride,31);
+}
+
+vint16m2_t
+test___riscv_vlse16_v_i16m2_tum(vbool8_t mask,vint16m2_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m2_tum(mask,merge,base,bstride,31);
+}
+
+vint16m4_t
+test___riscv_vlse16_v_i16m4_tum(vbool4_t mask,vint16m4_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m4_tum(mask,merge,base,bstride,31);
+}
+
+vint16m8_t
+test___riscv_vlse16_v_i16m8_tum(vbool2_t mask,vint16m8_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m8_tum(mask,merge,base,bstride,31);
+}
+
+vuint16mf4_t
+test___riscv_vlse16_v_u16mf4_tum(vbool64_t mask,vuint16mf4_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf4_tum(mask,merge,base,bstride,31);
+}
+
+vuint16mf2_t
+test___riscv_vlse16_v_u16mf2_tum(vbool32_t mask,vuint16mf2_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf2_tum(mask,merge,base,bstride,31);
+}
+
+vuint16m1_t
+test___riscv_vlse16_v_u16m1_tum(vbool16_t mask,vuint16m1_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m1_tum(mask,merge,base,bstride,31);
+}
+
+vuint16m2_t
+test___riscv_vlse16_v_u16m2_tum(vbool8_t mask,vuint16m2_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m2_tum(mask,merge,base,bstride,31);
+}
+
+vuint16m4_t
+test___riscv_vlse16_v_u16m4_tum(vbool4_t mask,vuint16m4_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m4_tum(mask,merge,base,bstride,31);
+}
+
+vuint16m8_t
+test___riscv_vlse16_v_u16m8_tum(vbool2_t mask,vuint16m8_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m8_tum(mask,merge,base,bstride,31);
+}
+
+vint32mf2_t
+test___riscv_vlse32_v_i32mf2_tum(vbool64_t mask,vint32mf2_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32mf2_tum(mask,merge,base,bstride,31);
+}
+
+vint32m1_t
+test___riscv_vlse32_v_i32m1_tum(vbool32_t mask,vint32m1_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m1_tum(mask,merge,base,bstride,31);
+}
+
+vint32m2_t
+test___riscv_vlse32_v_i32m2_tum(vbool16_t mask,vint32m2_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m2_tum(mask,merge,base,bstride,31);
+}
+
+vint32m4_t
+test___riscv_vlse32_v_i32m4_tum(vbool8_t mask,vint32m4_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m4_tum(mask,merge,base,bstride,31);
+}
+
+vint32m8_t
+test___riscv_vlse32_v_i32m8_tum(vbool4_t mask,vint32m8_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m8_tum(mask,merge,base,bstride,31);
+}
+
+vuint32mf2_t
+test___riscv_vlse32_v_u32mf2_tum(vbool64_t mask,vuint32mf2_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32mf2_tum(mask,merge,base,bstride,31);
+}
+
+vuint32m1_t
+test___riscv_vlse32_v_u32m1_tum(vbool32_t mask,vuint32m1_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m1_tum(mask,merge,base,bstride,31);
+}
+
+vuint32m2_t
+test___riscv_vlse32_v_u32m2_tum(vbool16_t mask,vuint32m2_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m2_tum(mask,merge,base,bstride,31);
+}
+
+vuint32m4_t
+test___riscv_vlse32_v_u32m4_tum(vbool8_t mask,vuint32m4_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m4_tum(mask,merge,base,bstride,31);
+}
+
+vuint32m8_t
+test___riscv_vlse32_v_u32m8_tum(vbool4_t mask,vuint32m8_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m8_tum(mask,merge,base,bstride,31);
+}
+
+vfloat32mf2_t
+test___riscv_vlse32_v_f32mf2_tum(vbool64_t mask,vfloat32mf2_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32mf2_tum(mask,merge,base,bstride,31);
+}
+
+vfloat32m1_t
+test___riscv_vlse32_v_f32m1_tum(vbool32_t mask,vfloat32m1_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m1_tum(mask,merge,base,bstride,31);
+}
+
+vfloat32m2_t
+test___riscv_vlse32_v_f32m2_tum(vbool16_t mask,vfloat32m2_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m2_tum(mask,merge,base,bstride,31);
+}
+
+vfloat32m4_t
+test___riscv_vlse32_v_f32m4_tum(vbool8_t mask,vfloat32m4_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m4_tum(mask,merge,base,bstride,31);
+}
+
+vfloat32m8_t
+test___riscv_vlse32_v_f32m8_tum(vbool4_t mask,vfloat32m8_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m8_tum(mask,merge,base,bstride,31);
+}
+
+vint64m1_t
+test___riscv_vlse64_v_i64m1_tum(vbool64_t mask,vint64m1_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m1_tum(mask,merge,base,bstride,31);
+}
+
+vint64m2_t
+test___riscv_vlse64_v_i64m2_tum(vbool32_t mask,vint64m2_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m2_tum(mask,merge,base,bstride,31);
+}
+
+vint64m4_t
+test___riscv_vlse64_v_i64m4_tum(vbool16_t mask,vint64m4_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m4_tum(mask,merge,base,bstride,31);
+}
+
+vint64m8_t
+test___riscv_vlse64_v_i64m8_tum(vbool8_t mask,vint64m8_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m8_tum(mask,merge,base,bstride,31);
+}
+
+vuint64m1_t
+test___riscv_vlse64_v_u64m1_tum(vbool64_t mask,vuint64m1_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m1_tum(mask,merge,base,bstride,31);
+}
+
+vuint64m2_t
+test___riscv_vlse64_v_u64m2_tum(vbool32_t mask,vuint64m2_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m2_tum(mask,merge,base,bstride,31);
+}
+
+vuint64m4_t
+test___riscv_vlse64_v_u64m4_tum(vbool16_t mask,vuint64m4_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m4_tum(mask,merge,base,bstride,31);
+}
+
+vuint64m8_t
+test___riscv_vlse64_v_u64m8_tum(vbool8_t mask,vuint64m8_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m8_tum(mask,merge,base,bstride,31);
+}
+
+vfloat64m1_t
+test___riscv_vlse64_v_f64m1_tum(vbool64_t mask,vfloat64m1_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m1_tum(mask,merge,base,bstride,31);
+}
+
+vfloat64m2_t
+test___riscv_vlse64_v_f64m2_tum(vbool32_t mask,vfloat64m2_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m2_tum(mask,merge,base,bstride,31);
+}
+
+vfloat64m4_t
+test___riscv_vlse64_v_f64m4_tum(vbool16_t mask,vfloat64m4_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m4_tum(mask,merge,base,bstride,31);
+}
+
+vfloat64m8_t
+test___riscv_vlse64_v_f64m8_tum(vbool8_t mask,vfloat64m8_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m8_tum(mask,merge,base,bstride,31);
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_tum-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_tum-3.c
new file mode 100644
index 0000000..5e62785
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_tum-3.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vlse8_v_i8mf8_tum(vbool64_t mask,vint8mf8_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf8_tum(mask,merge,base,bstride,32);
+}
+
+vint8mf4_t
+test___riscv_vlse8_v_i8mf4_tum(vbool32_t mask,vint8mf4_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf4_tum(mask,merge,base,bstride,32);
+}
+
+vint8mf2_t
+test___riscv_vlse8_v_i8mf2_tum(vbool16_t mask,vint8mf2_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf2_tum(mask,merge,base,bstride,32);
+}
+
+vint8m1_t
+test___riscv_vlse8_v_i8m1_tum(vbool8_t mask,vint8m1_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m1_tum(mask,merge,base,bstride,32);
+}
+
+vint8m2_t
+test___riscv_vlse8_v_i8m2_tum(vbool4_t mask,vint8m2_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m2_tum(mask,merge,base,bstride,32);
+}
+
+vint8m4_t
+test___riscv_vlse8_v_i8m4_tum(vbool2_t mask,vint8m4_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m4_tum(mask,merge,base,bstride,32);
+}
+
+vint8m8_t
+test___riscv_vlse8_v_i8m8_tum(vbool1_t mask,vint8m8_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m8_tum(mask,merge,base,bstride,32);
+}
+
+vuint8mf8_t
+test___riscv_vlse8_v_u8mf8_tum(vbool64_t mask,vuint8mf8_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf8_tum(mask,merge,base,bstride,32);
+}
+
+vuint8mf4_t
+test___riscv_vlse8_v_u8mf4_tum(vbool32_t mask,vuint8mf4_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf4_tum(mask,merge,base,bstride,32);
+}
+
+vuint8mf2_t
+test___riscv_vlse8_v_u8mf2_tum(vbool16_t mask,vuint8mf2_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf2_tum(mask,merge,base,bstride,32);
+}
+
+vuint8m1_t
+test___riscv_vlse8_v_u8m1_tum(vbool8_t mask,vuint8m1_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m1_tum(mask,merge,base,bstride,32);
+}
+
+vuint8m2_t
+test___riscv_vlse8_v_u8m2_tum(vbool4_t mask,vuint8m2_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m2_tum(mask,merge,base,bstride,32);
+}
+
+vuint8m4_t
+test___riscv_vlse8_v_u8m4_tum(vbool2_t mask,vuint8m4_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m4_tum(mask,merge,base,bstride,32);
+}
+
+vuint8m8_t
+test___riscv_vlse8_v_u8m8_tum(vbool1_t mask,vuint8m8_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m8_tum(mask,merge,base,bstride,32);
+}
+
+vint16mf4_t
+test___riscv_vlse16_v_i16mf4_tum(vbool64_t mask,vint16mf4_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf4_tum(mask,merge,base,bstride,32);
+}
+
+vint16mf2_t
+test___riscv_vlse16_v_i16mf2_tum(vbool32_t mask,vint16mf2_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf2_tum(mask,merge,base,bstride,32);
+}
+
+vint16m1_t
+test___riscv_vlse16_v_i16m1_tum(vbool16_t mask,vint16m1_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m1_tum(mask,merge,base,bstride,32);
+}
+
+vint16m2_t
+test___riscv_vlse16_v_i16m2_tum(vbool8_t mask,vint16m2_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m2_tum(mask,merge,base,bstride,32);
+}
+
+vint16m4_t
+test___riscv_vlse16_v_i16m4_tum(vbool4_t mask,vint16m4_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m4_tum(mask,merge,base,bstride,32);
+}
+
+vint16m8_t
+test___riscv_vlse16_v_i16m8_tum(vbool2_t mask,vint16m8_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m8_tum(mask,merge,base,bstride,32);
+}
+
+vuint16mf4_t
+test___riscv_vlse16_v_u16mf4_tum(vbool64_t mask,vuint16mf4_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf4_tum(mask,merge,base,bstride,32);
+}
+
+vuint16mf2_t
+test___riscv_vlse16_v_u16mf2_tum(vbool32_t mask,vuint16mf2_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf2_tum(mask,merge,base,bstride,32);
+}
+
+vuint16m1_t
+test___riscv_vlse16_v_u16m1_tum(vbool16_t mask,vuint16m1_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m1_tum(mask,merge,base,bstride,32);
+}
+
+vuint16m2_t
+test___riscv_vlse16_v_u16m2_tum(vbool8_t mask,vuint16m2_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m2_tum(mask,merge,base,bstride,32);
+}
+
+vuint16m4_t
+test___riscv_vlse16_v_u16m4_tum(vbool4_t mask,vuint16m4_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m4_tum(mask,merge,base,bstride,32);
+}
+
+vuint16m8_t
+test___riscv_vlse16_v_u16m8_tum(vbool2_t mask,vuint16m8_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m8_tum(mask,merge,base,bstride,32);
+}
+
+vint32mf2_t
+test___riscv_vlse32_v_i32mf2_tum(vbool64_t mask,vint32mf2_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32mf2_tum(mask,merge,base,bstride,32);
+}
+
+vint32m1_t
+test___riscv_vlse32_v_i32m1_tum(vbool32_t mask,vint32m1_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m1_tum(mask,merge,base,bstride,32);
+}
+
+vint32m2_t
+test___riscv_vlse32_v_i32m2_tum(vbool16_t mask,vint32m2_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m2_tum(mask,merge,base,bstride,32);
+}
+
+vint32m4_t
+test___riscv_vlse32_v_i32m4_tum(vbool8_t mask,vint32m4_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m4_tum(mask,merge,base,bstride,32);
+}
+
+vint32m8_t
+test___riscv_vlse32_v_i32m8_tum(vbool4_t mask,vint32m8_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m8_tum(mask,merge,base,bstride,32);
+}
+
+vuint32mf2_t
+test___riscv_vlse32_v_u32mf2_tum(vbool64_t mask,vuint32mf2_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32mf2_tum(mask,merge,base,bstride,32);
+}
+
+vuint32m1_t
+test___riscv_vlse32_v_u32m1_tum(vbool32_t mask,vuint32m1_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m1_tum(mask,merge,base,bstride,32);
+}
+
+vuint32m2_t
+test___riscv_vlse32_v_u32m2_tum(vbool16_t mask,vuint32m2_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m2_tum(mask,merge,base,bstride,32);
+}
+
+vuint32m4_t
+test___riscv_vlse32_v_u32m4_tum(vbool8_t mask,vuint32m4_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m4_tum(mask,merge,base,bstride,32);
+}
+
+vuint32m8_t
+test___riscv_vlse32_v_u32m8_tum(vbool4_t mask,vuint32m8_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m8_tum(mask,merge,base,bstride,32);
+}
+
+vfloat32mf2_t
+test___riscv_vlse32_v_f32mf2_tum(vbool64_t mask,vfloat32mf2_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32mf2_tum(mask,merge,base,bstride,32);
+}
+
+vfloat32m1_t
+test___riscv_vlse32_v_f32m1_tum(vbool32_t mask,vfloat32m1_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m1_tum(mask,merge,base,bstride,32);
+}
+
+vfloat32m2_t
+test___riscv_vlse32_v_f32m2_tum(vbool16_t mask,vfloat32m2_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m2_tum(mask,merge,base,bstride,32);
+}
+
+vfloat32m4_t
+test___riscv_vlse32_v_f32m4_tum(vbool8_t mask,vfloat32m4_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m4_tum(mask,merge,base,bstride,32);
+}
+
+vfloat32m8_t
+test___riscv_vlse32_v_f32m8_tum(vbool4_t mask,vfloat32m8_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m8_tum(mask,merge,base,bstride,32);
+}
+
+vint64m1_t
+test___riscv_vlse64_v_i64m1_tum(vbool64_t mask,vint64m1_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m1_tum(mask,merge,base,bstride,32);
+}
+
+vint64m2_t
+test___riscv_vlse64_v_i64m2_tum(vbool32_t mask,vint64m2_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m2_tum(mask,merge,base,bstride,32);
+}
+
+vint64m4_t
+test___riscv_vlse64_v_i64m4_tum(vbool16_t mask,vint64m4_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m4_tum(mask,merge,base,bstride,32);
+}
+
+vint64m8_t
+test___riscv_vlse64_v_i64m8_tum(vbool8_t mask,vint64m8_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m8_tum(mask,merge,base,bstride,32);
+}
+
+vuint64m1_t
+test___riscv_vlse64_v_u64m1_tum(vbool64_t mask,vuint64m1_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m1_tum(mask,merge,base,bstride,32);
+}
+
+vuint64m2_t
+test___riscv_vlse64_v_u64m2_tum(vbool32_t mask,vuint64m2_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m2_tum(mask,merge,base,bstride,32);
+}
+
+vuint64m4_t
+test___riscv_vlse64_v_u64m4_tum(vbool16_t mask,vuint64m4_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m4_tum(mask,merge,base,bstride,32);
+}
+
+vuint64m8_t
+test___riscv_vlse64_v_u64m8_tum(vbool8_t mask,vuint64m8_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m8_tum(mask,merge,base,bstride,32);
+}
+
+vfloat64m1_t
+test___riscv_vlse64_v_f64m1_tum(vbool64_t mask,vfloat64m1_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m1_tum(mask,merge,base,bstride,32);
+}
+
+vfloat64m2_t
+test___riscv_vlse64_v_f64m2_tum(vbool32_t mask,vfloat64m2_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m2_tum(mask,merge,base,bstride,32);
+}
+
+vfloat64m4_t
+test___riscv_vlse64_v_f64m4_tum(vbool16_t mask,vfloat64m4_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m4_tum(mask,merge,base,bstride,32);
+}
+
+vfloat64m8_t
+test___riscv_vlse64_v_f64m8_tum(vbool8_t mask,vfloat64m8_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m8_tum(mask,merge,base,bstride,32);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_tumu-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_tumu-1.c
new file mode 100644
index 0000000..35c846e
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_tumu-1.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vlse8_v_i8mf8_tumu(vbool64_t mask,vint8mf8_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf8_tumu(mask,merge,base,bstride,vl);
+}
+
+vint8mf4_t
+test___riscv_vlse8_v_i8mf4_tumu(vbool32_t mask,vint8mf4_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf4_tumu(mask,merge,base,bstride,vl);
+}
+
+vint8mf2_t
+test___riscv_vlse8_v_i8mf2_tumu(vbool16_t mask,vint8mf2_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf2_tumu(mask,merge,base,bstride,vl);
+}
+
+vint8m1_t
+test___riscv_vlse8_v_i8m1_tumu(vbool8_t mask,vint8m1_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m1_tumu(mask,merge,base,bstride,vl);
+}
+
+vint8m2_t
+test___riscv_vlse8_v_i8m2_tumu(vbool4_t mask,vint8m2_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m2_tumu(mask,merge,base,bstride,vl);
+}
+
+vint8m4_t
+test___riscv_vlse8_v_i8m4_tumu(vbool2_t mask,vint8m4_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m4_tumu(mask,merge,base,bstride,vl);
+}
+
+vint8m8_t
+test___riscv_vlse8_v_i8m8_tumu(vbool1_t mask,vint8m8_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m8_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint8mf8_t
+test___riscv_vlse8_v_u8mf8_tumu(vbool64_t mask,vuint8mf8_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf8_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint8mf4_t
+test___riscv_vlse8_v_u8mf4_tumu(vbool32_t mask,vuint8mf4_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf4_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint8mf2_t
+test___riscv_vlse8_v_u8mf2_tumu(vbool16_t mask,vuint8mf2_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf2_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint8m1_t
+test___riscv_vlse8_v_u8m1_tumu(vbool8_t mask,vuint8m1_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m1_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint8m2_t
+test___riscv_vlse8_v_u8m2_tumu(vbool4_t mask,vuint8m2_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m2_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint8m4_t
+test___riscv_vlse8_v_u8m4_tumu(vbool2_t mask,vuint8m4_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m4_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint8m8_t
+test___riscv_vlse8_v_u8m8_tumu(vbool1_t mask,vuint8m8_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m8_tumu(mask,merge,base,bstride,vl);
+}
+
+vint16mf4_t
+test___riscv_vlse16_v_i16mf4_tumu(vbool64_t mask,vint16mf4_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf4_tumu(mask,merge,base,bstride,vl);
+}
+
+vint16mf2_t
+test___riscv_vlse16_v_i16mf2_tumu(vbool32_t mask,vint16mf2_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf2_tumu(mask,merge,base,bstride,vl);
+}
+
+vint16m1_t
+test___riscv_vlse16_v_i16m1_tumu(vbool16_t mask,vint16m1_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m1_tumu(mask,merge,base,bstride,vl);
+}
+
+vint16m2_t
+test___riscv_vlse16_v_i16m2_tumu(vbool8_t mask,vint16m2_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m2_tumu(mask,merge,base,bstride,vl);
+}
+
+vint16m4_t
+test___riscv_vlse16_v_i16m4_tumu(vbool4_t mask,vint16m4_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m4_tumu(mask,merge,base,bstride,vl);
+}
+
+vint16m8_t
+test___riscv_vlse16_v_i16m8_tumu(vbool2_t mask,vint16m8_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m8_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint16mf4_t
+test___riscv_vlse16_v_u16mf4_tumu(vbool64_t mask,vuint16mf4_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf4_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint16mf2_t
+test___riscv_vlse16_v_u16mf2_tumu(vbool32_t mask,vuint16mf2_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf2_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint16m1_t
+test___riscv_vlse16_v_u16m1_tumu(vbool16_t mask,vuint16m1_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m1_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint16m2_t
+test___riscv_vlse16_v_u16m2_tumu(vbool8_t mask,vuint16m2_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m2_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint16m4_t
+test___riscv_vlse16_v_u16m4_tumu(vbool4_t mask,vuint16m4_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m4_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint16m8_t
+test___riscv_vlse16_v_u16m8_tumu(vbool2_t mask,vuint16m8_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m8_tumu(mask,merge,base,bstride,vl);
+}
+
+vint32mf2_t
+test___riscv_vlse32_v_i32mf2_tumu(vbool64_t mask,vint32mf2_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32mf2_tumu(mask,merge,base,bstride,vl);
+}
+
+vint32m1_t
+test___riscv_vlse32_v_i32m1_tumu(vbool32_t mask,vint32m1_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m1_tumu(mask,merge,base,bstride,vl);
+}
+
+vint32m2_t
+test___riscv_vlse32_v_i32m2_tumu(vbool16_t mask,vint32m2_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m2_tumu(mask,merge,base,bstride,vl);
+}
+
+vint32m4_t
+test___riscv_vlse32_v_i32m4_tumu(vbool8_t mask,vint32m4_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m4_tumu(mask,merge,base,bstride,vl);
+}
+
+vint32m8_t
+test___riscv_vlse32_v_i32m8_tumu(vbool4_t mask,vint32m8_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m8_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint32mf2_t
+test___riscv_vlse32_v_u32mf2_tumu(vbool64_t mask,vuint32mf2_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32mf2_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint32m1_t
+test___riscv_vlse32_v_u32m1_tumu(vbool32_t mask,vuint32m1_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m1_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint32m2_t
+test___riscv_vlse32_v_u32m2_tumu(vbool16_t mask,vuint32m2_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m2_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint32m4_t
+test___riscv_vlse32_v_u32m4_tumu(vbool8_t mask,vuint32m4_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m4_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint32m8_t
+test___riscv_vlse32_v_u32m8_tumu(vbool4_t mask,vuint32m8_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m8_tumu(mask,merge,base,bstride,vl);
+}
+
+vfloat32mf2_t
+test___riscv_vlse32_v_f32mf2_tumu(vbool64_t mask,vfloat32mf2_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32mf2_tumu(mask,merge,base,bstride,vl);
+}
+
+vfloat32m1_t
+test___riscv_vlse32_v_f32m1_tumu(vbool32_t mask,vfloat32m1_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m1_tumu(mask,merge,base,bstride,vl);
+}
+
+vfloat32m2_t
+test___riscv_vlse32_v_f32m2_tumu(vbool16_t mask,vfloat32m2_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m2_tumu(mask,merge,base,bstride,vl);
+}
+
+vfloat32m4_t
+test___riscv_vlse32_v_f32m4_tumu(vbool8_t mask,vfloat32m4_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m4_tumu(mask,merge,base,bstride,vl);
+}
+
+vfloat32m8_t
+test___riscv_vlse32_v_f32m8_tumu(vbool4_t mask,vfloat32m8_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m8_tumu(mask,merge,base,bstride,vl);
+}
+
+vint64m1_t
+test___riscv_vlse64_v_i64m1_tumu(vbool64_t mask,vint64m1_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m1_tumu(mask,merge,base,bstride,vl);
+}
+
+vint64m2_t
+test___riscv_vlse64_v_i64m2_tumu(vbool32_t mask,vint64m2_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m2_tumu(mask,merge,base,bstride,vl);
+}
+
+vint64m4_t
+test___riscv_vlse64_v_i64m4_tumu(vbool16_t mask,vint64m4_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m4_tumu(mask,merge,base,bstride,vl);
+}
+
+vint64m8_t
+test___riscv_vlse64_v_i64m8_tumu(vbool8_t mask,vint64m8_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m8_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint64m1_t
+test___riscv_vlse64_v_u64m1_tumu(vbool64_t mask,vuint64m1_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m1_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint64m2_t
+test___riscv_vlse64_v_u64m2_tumu(vbool32_t mask,vuint64m2_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m2_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint64m4_t
+test___riscv_vlse64_v_u64m4_tumu(vbool16_t mask,vuint64m4_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m4_tumu(mask,merge,base,bstride,vl);
+}
+
+vuint64m8_t
+test___riscv_vlse64_v_u64m8_tumu(vbool8_t mask,vuint64m8_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m8_tumu(mask,merge,base,bstride,vl);
+}
+
+vfloat64m1_t
+test___riscv_vlse64_v_f64m1_tumu(vbool64_t mask,vfloat64m1_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m1_tumu(mask,merge,base,bstride,vl);
+}
+
+vfloat64m2_t
+test___riscv_vlse64_v_f64m2_tumu(vbool32_t mask,vfloat64m2_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m2_tumu(mask,merge,base,bstride,vl);
+}
+
+vfloat64m4_t
+test___riscv_vlse64_v_f64m4_tumu(vbool16_t mask,vfloat64m4_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m4_tumu(mask,merge,base,bstride,vl);
+}
+
+vfloat64m8_t
+test___riscv_vlse64_v_f64m8_tumu(vbool8_t mask,vfloat64m8_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m8_tumu(mask,merge,base,bstride,vl);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*mu\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_tumu-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_tumu-2.c
new file mode 100644
index 0000000..fa388fa
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_tumu-2.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vlse8_v_i8mf8_tumu(vbool64_t mask,vint8mf8_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf8_tumu(mask,merge,base,bstride,31);
+}
+
+vint8mf4_t
+test___riscv_vlse8_v_i8mf4_tumu(vbool32_t mask,vint8mf4_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf4_tumu(mask,merge,base,bstride,31);
+}
+
+vint8mf2_t
+test___riscv_vlse8_v_i8mf2_tumu(vbool16_t mask,vint8mf2_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf2_tumu(mask,merge,base,bstride,31);
+}
+
+vint8m1_t
+test___riscv_vlse8_v_i8m1_tumu(vbool8_t mask,vint8m1_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m1_tumu(mask,merge,base,bstride,31);
+}
+
+vint8m2_t
+test___riscv_vlse8_v_i8m2_tumu(vbool4_t mask,vint8m2_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m2_tumu(mask,merge,base,bstride,31);
+}
+
+vint8m4_t
+test___riscv_vlse8_v_i8m4_tumu(vbool2_t mask,vint8m4_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m4_tumu(mask,merge,base,bstride,31);
+}
+
+vint8m8_t
+test___riscv_vlse8_v_i8m8_tumu(vbool1_t mask,vint8m8_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m8_tumu(mask,merge,base,bstride,31);
+}
+
+vuint8mf8_t
+test___riscv_vlse8_v_u8mf8_tumu(vbool64_t mask,vuint8mf8_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf8_tumu(mask,merge,base,bstride,31);
+}
+
+vuint8mf4_t
+test___riscv_vlse8_v_u8mf4_tumu(vbool32_t mask,vuint8mf4_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf4_tumu(mask,merge,base,bstride,31);
+}
+
+vuint8mf2_t
+test___riscv_vlse8_v_u8mf2_tumu(vbool16_t mask,vuint8mf2_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf2_tumu(mask,merge,base,bstride,31);
+}
+
+vuint8m1_t
+test___riscv_vlse8_v_u8m1_tumu(vbool8_t mask,vuint8m1_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m1_tumu(mask,merge,base,bstride,31);
+}
+
+vuint8m2_t
+test___riscv_vlse8_v_u8m2_tumu(vbool4_t mask,vuint8m2_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m2_tumu(mask,merge,base,bstride,31);
+}
+
+vuint8m4_t
+test___riscv_vlse8_v_u8m4_tumu(vbool2_t mask,vuint8m4_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m4_tumu(mask,merge,base,bstride,31);
+}
+
+vuint8m8_t
+test___riscv_vlse8_v_u8m8_tumu(vbool1_t mask,vuint8m8_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m8_tumu(mask,merge,base,bstride,31);
+}
+
+vint16mf4_t
+test___riscv_vlse16_v_i16mf4_tumu(vbool64_t mask,vint16mf4_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf4_tumu(mask,merge,base,bstride,31);
+}
+
+vint16mf2_t
+test___riscv_vlse16_v_i16mf2_tumu(vbool32_t mask,vint16mf2_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf2_tumu(mask,merge,base,bstride,31);
+}
+
+vint16m1_t
+test___riscv_vlse16_v_i16m1_tumu(vbool16_t mask,vint16m1_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m1_tumu(mask,merge,base,bstride,31);
+}
+
+vint16m2_t
+test___riscv_vlse16_v_i16m2_tumu(vbool8_t mask,vint16m2_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m2_tumu(mask,merge,base,bstride,31);
+}
+
+vint16m4_t
+test___riscv_vlse16_v_i16m4_tumu(vbool4_t mask,vint16m4_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m4_tumu(mask,merge,base,bstride,31);
+}
+
+vint16m8_t
+test___riscv_vlse16_v_i16m8_tumu(vbool2_t mask,vint16m8_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m8_tumu(mask,merge,base,bstride,31);
+}
+
+vuint16mf4_t
+test___riscv_vlse16_v_u16mf4_tumu(vbool64_t mask,vuint16mf4_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf4_tumu(mask,merge,base,bstride,31);
+}
+
+vuint16mf2_t
+test___riscv_vlse16_v_u16mf2_tumu(vbool32_t mask,vuint16mf2_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf2_tumu(mask,merge,base,bstride,31);
+}
+
+vuint16m1_t
+test___riscv_vlse16_v_u16m1_tumu(vbool16_t mask,vuint16m1_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m1_tumu(mask,merge,base,bstride,31);
+}
+
+vuint16m2_t
+test___riscv_vlse16_v_u16m2_tumu(vbool8_t mask,vuint16m2_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m2_tumu(mask,merge,base,bstride,31);
+}
+
+vuint16m4_t
+test___riscv_vlse16_v_u16m4_tumu(vbool4_t mask,vuint16m4_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m4_tumu(mask,merge,base,bstride,31);
+}
+
+vuint16m8_t
+test___riscv_vlse16_v_u16m8_tumu(vbool2_t mask,vuint16m8_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m8_tumu(mask,merge,base,bstride,31);
+}
+
+vint32mf2_t
+test___riscv_vlse32_v_i32mf2_tumu(vbool64_t mask,vint32mf2_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32mf2_tumu(mask,merge,base,bstride,31);
+}
+
+vint32m1_t
+test___riscv_vlse32_v_i32m1_tumu(vbool32_t mask,vint32m1_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m1_tumu(mask,merge,base,bstride,31);
+}
+
+vint32m2_t
+test___riscv_vlse32_v_i32m2_tumu(vbool16_t mask,vint32m2_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m2_tumu(mask,merge,base,bstride,31);
+}
+
+vint32m4_t
+test___riscv_vlse32_v_i32m4_tumu(vbool8_t mask,vint32m4_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m4_tumu(mask,merge,base,bstride,31);
+}
+
+vint32m8_t
+test___riscv_vlse32_v_i32m8_tumu(vbool4_t mask,vint32m8_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m8_tumu(mask,merge,base,bstride,31);
+}
+
+vuint32mf2_t
+test___riscv_vlse32_v_u32mf2_tumu(vbool64_t mask,vuint32mf2_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32mf2_tumu(mask,merge,base,bstride,31);
+}
+
+vuint32m1_t
+test___riscv_vlse32_v_u32m1_tumu(vbool32_t mask,vuint32m1_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m1_tumu(mask,merge,base,bstride,31);
+}
+
+vuint32m2_t
+test___riscv_vlse32_v_u32m2_tumu(vbool16_t mask,vuint32m2_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m2_tumu(mask,merge,base,bstride,31);
+}
+
+vuint32m4_t
+test___riscv_vlse32_v_u32m4_tumu(vbool8_t mask,vuint32m4_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m4_tumu(mask,merge,base,bstride,31);
+}
+
+vuint32m8_t
+test___riscv_vlse32_v_u32m8_tumu(vbool4_t mask,vuint32m8_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m8_tumu(mask,merge,base,bstride,31);
+}
+
+vfloat32mf2_t
+test___riscv_vlse32_v_f32mf2_tumu(vbool64_t mask,vfloat32mf2_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32mf2_tumu(mask,merge,base,bstride,31);
+}
+
+vfloat32m1_t
+test___riscv_vlse32_v_f32m1_tumu(vbool32_t mask,vfloat32m1_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m1_tumu(mask,merge,base,bstride,31);
+}
+
+vfloat32m2_t
+test___riscv_vlse32_v_f32m2_tumu(vbool16_t mask,vfloat32m2_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m2_tumu(mask,merge,base,bstride,31);
+}
+
+vfloat32m4_t
+test___riscv_vlse32_v_f32m4_tumu(vbool8_t mask,vfloat32m4_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m4_tumu(mask,merge,base,bstride,31);
+}
+
+vfloat32m8_t
+test___riscv_vlse32_v_f32m8_tumu(vbool4_t mask,vfloat32m8_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m8_tumu(mask,merge,base,bstride,31);
+}
+
+vint64m1_t
+test___riscv_vlse64_v_i64m1_tumu(vbool64_t mask,vint64m1_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m1_tumu(mask,merge,base,bstride,31);
+}
+
+vint64m2_t
+test___riscv_vlse64_v_i64m2_tumu(vbool32_t mask,vint64m2_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m2_tumu(mask,merge,base,bstride,31);
+}
+
+vint64m4_t
+test___riscv_vlse64_v_i64m4_tumu(vbool16_t mask,vint64m4_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m4_tumu(mask,merge,base,bstride,31);
+}
+
+vint64m8_t
+test___riscv_vlse64_v_i64m8_tumu(vbool8_t mask,vint64m8_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m8_tumu(mask,merge,base,bstride,31);
+}
+
+vuint64m1_t
+test___riscv_vlse64_v_u64m1_tumu(vbool64_t mask,vuint64m1_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m1_tumu(mask,merge,base,bstride,31);
+}
+
+vuint64m2_t
+test___riscv_vlse64_v_u64m2_tumu(vbool32_t mask,vuint64m2_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m2_tumu(mask,merge,base,bstride,31);
+}
+
+vuint64m4_t
+test___riscv_vlse64_v_u64m4_tumu(vbool16_t mask,vuint64m4_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m4_tumu(mask,merge,base,bstride,31);
+}
+
+vuint64m8_t
+test___riscv_vlse64_v_u64m8_tumu(vbool8_t mask,vuint64m8_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m8_tumu(mask,merge,base,bstride,31);
+}
+
+vfloat64m1_t
+test___riscv_vlse64_v_f64m1_tumu(vbool64_t mask,vfloat64m1_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m1_tumu(mask,merge,base,bstride,31);
+}
+
+vfloat64m2_t
+test___riscv_vlse64_v_f64m2_tumu(vbool32_t mask,vfloat64m2_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m2_tumu(mask,merge,base,bstride,31);
+}
+
+vfloat64m4_t
+test___riscv_vlse64_v_f64m4_tumu(vbool16_t mask,vfloat64m4_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m4_tumu(mask,merge,base,bstride,31);
+}
+
+vfloat64m8_t
+test___riscv_vlse64_v_f64m8_tumu(vbool8_t mask,vfloat64m8_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m8_tumu(mask,merge,base,bstride,31);
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*tu,\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*tu,\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*tu,\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*mu\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*mu\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*mu\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*mu\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*mu\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*mu\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*mu\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*mu\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*mu\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_tumu-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_tumu-3.c
new file mode 100644
index 0000000..659f57b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vlse_tumu-3.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t
+test___riscv_vlse8_v_i8mf8_tumu(vbool64_t mask,vint8mf8_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf8_tumu(mask,merge,base,bstride,32);
+}
+
+vint8mf4_t
+test___riscv_vlse8_v_i8mf4_tumu(vbool32_t mask,vint8mf4_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf4_tumu(mask,merge,base,bstride,32);
+}
+
+vint8mf2_t
+test___riscv_vlse8_v_i8mf2_tumu(vbool16_t mask,vint8mf2_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8mf2_tumu(mask,merge,base,bstride,32);
+}
+
+vint8m1_t
+test___riscv_vlse8_v_i8m1_tumu(vbool8_t mask,vint8m1_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m1_tumu(mask,merge,base,bstride,32);
+}
+
+vint8m2_t
+test___riscv_vlse8_v_i8m2_tumu(vbool4_t mask,vint8m2_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m2_tumu(mask,merge,base,bstride,32);
+}
+
+vint8m4_t
+test___riscv_vlse8_v_i8m4_tumu(vbool2_t mask,vint8m4_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m4_tumu(mask,merge,base,bstride,32);
+}
+
+vint8m8_t
+test___riscv_vlse8_v_i8m8_tumu(vbool1_t mask,vint8m8_t merge,int8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_i8m8_tumu(mask,merge,base,bstride,32);
+}
+
+vuint8mf8_t
+test___riscv_vlse8_v_u8mf8_tumu(vbool64_t mask,vuint8mf8_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf8_tumu(mask,merge,base,bstride,32);
+}
+
+vuint8mf4_t
+test___riscv_vlse8_v_u8mf4_tumu(vbool32_t mask,vuint8mf4_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf4_tumu(mask,merge,base,bstride,32);
+}
+
+vuint8mf2_t
+test___riscv_vlse8_v_u8mf2_tumu(vbool16_t mask,vuint8mf2_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8mf2_tumu(mask,merge,base,bstride,32);
+}
+
+vuint8m1_t
+test___riscv_vlse8_v_u8m1_tumu(vbool8_t mask,vuint8m1_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m1_tumu(mask,merge,base,bstride,32);
+}
+
+vuint8m2_t
+test___riscv_vlse8_v_u8m2_tumu(vbool4_t mask,vuint8m2_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m2_tumu(mask,merge,base,bstride,32);
+}
+
+vuint8m4_t
+test___riscv_vlse8_v_u8m4_tumu(vbool2_t mask,vuint8m4_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m4_tumu(mask,merge,base,bstride,32);
+}
+
+vuint8m8_t
+test___riscv_vlse8_v_u8m8_tumu(vbool1_t mask,vuint8m8_t merge,uint8_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse8_v_u8m8_tumu(mask,merge,base,bstride,32);
+}
+
+vint16mf4_t
+test___riscv_vlse16_v_i16mf4_tumu(vbool64_t mask,vint16mf4_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf4_tumu(mask,merge,base,bstride,32);
+}
+
+vint16mf2_t
+test___riscv_vlse16_v_i16mf2_tumu(vbool32_t mask,vint16mf2_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16mf2_tumu(mask,merge,base,bstride,32);
+}
+
+vint16m1_t
+test___riscv_vlse16_v_i16m1_tumu(vbool16_t mask,vint16m1_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m1_tumu(mask,merge,base,bstride,32);
+}
+
+vint16m2_t
+test___riscv_vlse16_v_i16m2_tumu(vbool8_t mask,vint16m2_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m2_tumu(mask,merge,base,bstride,32);
+}
+
+vint16m4_t
+test___riscv_vlse16_v_i16m4_tumu(vbool4_t mask,vint16m4_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m4_tumu(mask,merge,base,bstride,32);
+}
+
+vint16m8_t
+test___riscv_vlse16_v_i16m8_tumu(vbool2_t mask,vint16m8_t merge,int16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_i16m8_tumu(mask,merge,base,bstride,32);
+}
+
+vuint16mf4_t
+test___riscv_vlse16_v_u16mf4_tumu(vbool64_t mask,vuint16mf4_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf4_tumu(mask,merge,base,bstride,32);
+}
+
+vuint16mf2_t
+test___riscv_vlse16_v_u16mf2_tumu(vbool32_t mask,vuint16mf2_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16mf2_tumu(mask,merge,base,bstride,32);
+}
+
+vuint16m1_t
+test___riscv_vlse16_v_u16m1_tumu(vbool16_t mask,vuint16m1_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m1_tumu(mask,merge,base,bstride,32);
+}
+
+vuint16m2_t
+test___riscv_vlse16_v_u16m2_tumu(vbool8_t mask,vuint16m2_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m2_tumu(mask,merge,base,bstride,32);
+}
+
+vuint16m4_t
+test___riscv_vlse16_v_u16m4_tumu(vbool4_t mask,vuint16m4_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m4_tumu(mask,merge,base,bstride,32);
+}
+
+vuint16m8_t
+test___riscv_vlse16_v_u16m8_tumu(vbool2_t mask,vuint16m8_t merge,uint16_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse16_v_u16m8_tumu(mask,merge,base,bstride,32);
+}
+
+vint32mf2_t
+test___riscv_vlse32_v_i32mf2_tumu(vbool64_t mask,vint32mf2_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32mf2_tumu(mask,merge,base,bstride,32);
+}
+
+vint32m1_t
+test___riscv_vlse32_v_i32m1_tumu(vbool32_t mask,vint32m1_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m1_tumu(mask,merge,base,bstride,32);
+}
+
+vint32m2_t
+test___riscv_vlse32_v_i32m2_tumu(vbool16_t mask,vint32m2_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m2_tumu(mask,merge,base,bstride,32);
+}
+
+vint32m4_t
+test___riscv_vlse32_v_i32m4_tumu(vbool8_t mask,vint32m4_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m4_tumu(mask,merge,base,bstride,32);
+}
+
+vint32m8_t
+test___riscv_vlse32_v_i32m8_tumu(vbool4_t mask,vint32m8_t merge,int32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_i32m8_tumu(mask,merge,base,bstride,32);
+}
+
+vuint32mf2_t
+test___riscv_vlse32_v_u32mf2_tumu(vbool64_t mask,vuint32mf2_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32mf2_tumu(mask,merge,base,bstride,32);
+}
+
+vuint32m1_t
+test___riscv_vlse32_v_u32m1_tumu(vbool32_t mask,vuint32m1_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m1_tumu(mask,merge,base,bstride,32);
+}
+
+vuint32m2_t
+test___riscv_vlse32_v_u32m2_tumu(vbool16_t mask,vuint32m2_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m2_tumu(mask,merge,base,bstride,32);
+}
+
+vuint32m4_t
+test___riscv_vlse32_v_u32m4_tumu(vbool8_t mask,vuint32m4_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m4_tumu(mask,merge,base,bstride,32);
+}
+
+vuint32m8_t
+test___riscv_vlse32_v_u32m8_tumu(vbool4_t mask,vuint32m8_t merge,uint32_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_u32m8_tumu(mask,merge,base,bstride,32);
+}
+
+vfloat32mf2_t
+test___riscv_vlse32_v_f32mf2_tumu(vbool64_t mask,vfloat32mf2_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32mf2_tumu(mask,merge,base,bstride,32);
+}
+
+vfloat32m1_t
+test___riscv_vlse32_v_f32m1_tumu(vbool32_t mask,vfloat32m1_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m1_tumu(mask,merge,base,bstride,32);
+}
+
+vfloat32m2_t
+test___riscv_vlse32_v_f32m2_tumu(vbool16_t mask,vfloat32m2_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m2_tumu(mask,merge,base,bstride,32);
+}
+
+vfloat32m4_t
+test___riscv_vlse32_v_f32m4_tumu(vbool8_t mask,vfloat32m4_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m4_tumu(mask,merge,base,bstride,32);
+}
+
+vfloat32m8_t
+test___riscv_vlse32_v_f32m8_tumu(vbool4_t mask,vfloat32m8_t merge,float* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse32_v_f32m8_tumu(mask,merge,base,bstride,32);
+}
+
+vint64m1_t
+test___riscv_vlse64_v_i64m1_tumu(vbool64_t mask,vint64m1_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m1_tumu(mask,merge,base,bstride,32);
+}
+
+vint64m2_t
+test___riscv_vlse64_v_i64m2_tumu(vbool32_t mask,vint64m2_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m2_tumu(mask,merge,base,bstride,32);
+}
+
+vint64m4_t
+test___riscv_vlse64_v_i64m4_tumu(vbool16_t mask,vint64m4_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m4_tumu(mask,merge,base,bstride,32);
+}
+
+vint64m8_t
+test___riscv_vlse64_v_i64m8_tumu(vbool8_t mask,vint64m8_t merge,int64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_i64m8_tumu(mask,merge,base,bstride,32);
+}
+
+vuint64m1_t
+test___riscv_vlse64_v_u64m1_tumu(vbool64_t mask,vuint64m1_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m1_tumu(mask,merge,base,bstride,32);
+}
+
+vuint64m2_t
+test___riscv_vlse64_v_u64m2_tumu(vbool32_t mask,vuint64m2_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m2_tumu(mask,merge,base,bstride,32);
+}
+
+vuint64m4_t
+test___riscv_vlse64_v_u64m4_tumu(vbool16_t mask,vuint64m4_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m4_tumu(mask,merge,base,bstride,32);
+}
+
+vuint64m8_t
+test___riscv_vlse64_v_u64m8_tumu(vbool8_t mask,vuint64m8_t merge,uint64_t* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_u64m8_tumu(mask,merge,base,bstride,32);
+}
+
+vfloat64m1_t
+test___riscv_vlse64_v_f64m1_tumu(vbool64_t mask,vfloat64m1_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m1_tumu(mask,merge,base,bstride,32);
+}
+
+vfloat64m2_t
+test___riscv_vlse64_v_f64m2_tumu(vbool32_t mask,vfloat64m2_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m2_tumu(mask,merge,base,bstride,32);
+}
+
+vfloat64m4_t
+test___riscv_vlse64_v_f64m4_tumu(vbool16_t mask,vfloat64m4_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m4_tumu(mask,merge,base,bstride,32);
+}
+
+vfloat64m8_t
+test___riscv_vlse64_v_f64m8_tumu(vbool8_t mask,vfloat64m8_t merge,double* base,ptrdiff_t bstride,size_t vl)
+{
+  return __riscv_vlse64_v_f64m8_tumu(mask,merge,base,bstride,32);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*mu\s+vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*mu\s+vlse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*mu\s+vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vlse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),[a-x0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v-1.c
new file mode 100644
index 0000000..3cbeef8
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v-1.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei16_v_i8mf8(const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf8(base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei16_v_i8mf4(const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf4(base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei16_v_i8mf2(const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf2(base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei16_v_i8m1(const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m1(base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei16_v_i8m2(const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m2(base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vluxei16_v_i8m4(const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m4(base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei16_v_i16mf4(const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf4(base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei16_v_i16mf2(const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf2(base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei16_v_i16m1(const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m1(base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei16_v_i16m2(const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m2(base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei16_v_i16m4(const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m4(base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vluxei16_v_i16m8(const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m8(base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei16_v_i32mf2(const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32mf2(base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei16_v_i32m1(const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m1(base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei16_v_i32m2(const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m2(base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei16_v_i32m4(const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m4(base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei16_v_i32m8(const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m8(base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei16_v_i64m1(const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m1(base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei16_v_i64m2(const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m2(base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei16_v_i64m4(const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m4(base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei16_v_i64m8(const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m8(base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16_v_u8mf8(const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf8(base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16_v_u8mf4(const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf4(base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16_v_u8mf2(const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf2(base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei16_v_u8m1(const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m1(base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei16_v_u8m2(const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m2(base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vluxei16_v_u8m4(const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m4(base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16_v_u16mf4(const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf4(base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16_v_u16mf2(const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf2(base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei16_v_u16m1(const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m1(base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei16_v_u16m2(const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m2(base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei16_v_u16m4(const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m4(base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vluxei16_v_u16m8(const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m8(base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16_v_u32mf2(const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32mf2(base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei16_v_u32m1(const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m1(base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei16_v_u32m2(const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m2(base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei16_v_u32m4(const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m4(base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei16_v_u32m8(const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m8(base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei16_v_u64m1(const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m1(base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei16_v_u64m2(const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m2(base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei16_v_u64m4(const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m4(base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei16_v_u64m8(const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m8(base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16_v_f32mf2(const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32mf2(base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16_v_f32m1(const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m1(base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16_v_f32m2(const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m2(base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16_v_f32m4(const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m4(base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16_v_f32m8(const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m8(base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16_v_f64m1(const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m1(base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16_v_f64m2(const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m2(base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16_v_f64m4(const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m4(base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16_v_f64m8(const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m8(base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v-2.c
new file mode 100644
index 0000000..4c306c8
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v-2.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei16_v_i8mf8(const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf8(base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei16_v_i8mf4(const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf4(base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei16_v_i8mf2(const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf2(base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei16_v_i8m1(const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m1(base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei16_v_i8m2(const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m2(base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vluxei16_v_i8m4(const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m4(base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei16_v_i16mf4(const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf4(base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei16_v_i16mf2(const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf2(base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei16_v_i16m1(const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m1(base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei16_v_i16m2(const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m2(base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei16_v_i16m4(const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m4(base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vluxei16_v_i16m8(const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m8(base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei16_v_i32mf2(const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32mf2(base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei16_v_i32m1(const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m1(base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei16_v_i32m2(const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m2(base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei16_v_i32m4(const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m4(base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei16_v_i32m8(const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m8(base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei16_v_i64m1(const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m1(base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei16_v_i64m2(const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m2(base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei16_v_i64m4(const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m4(base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei16_v_i64m8(const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m8(base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16_v_u8mf8(const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf8(base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16_v_u8mf4(const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf4(base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16_v_u8mf2(const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf2(base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei16_v_u8m1(const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m1(base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei16_v_u8m2(const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m2(base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vluxei16_v_u8m4(const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m4(base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16_v_u16mf4(const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf4(base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16_v_u16mf2(const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf2(base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei16_v_u16m1(const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m1(base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei16_v_u16m2(const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m2(base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei16_v_u16m4(const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m4(base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vluxei16_v_u16m8(const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m8(base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16_v_u32mf2(const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32mf2(base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei16_v_u32m1(const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m1(base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei16_v_u32m2(const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m2(base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei16_v_u32m4(const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m4(base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei16_v_u32m8(const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m8(base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei16_v_u64m1(const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m1(base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei16_v_u64m2(const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m2(base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei16_v_u64m4(const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m4(base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei16_v_u64m8(const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m8(base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16_v_f32mf2(const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32mf2(base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16_v_f32m1(const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m1(base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16_v_f32m2(const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m2(base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16_v_f32m4(const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m4(base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16_v_f32m8(const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m8(base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16_v_f64m1(const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m1(base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16_v_f64m2(const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m2(base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16_v_f64m4(const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m4(base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16_v_f64m8(const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m8(base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v-3.c
new file mode 100644
index 0000000..91edbbb
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v-3.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei16_v_i8mf8(const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf8(base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei16_v_i8mf4(const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf4(base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei16_v_i8mf2(const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf2(base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei16_v_i8m1(const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m1(base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei16_v_i8m2(const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m2(base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vluxei16_v_i8m4(const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m4(base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei16_v_i16mf4(const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf4(base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei16_v_i16mf2(const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf2(base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei16_v_i16m1(const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m1(base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei16_v_i16m2(const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m2(base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei16_v_i16m4(const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m4(base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vluxei16_v_i16m8(const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m8(base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei16_v_i32mf2(const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32mf2(base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei16_v_i32m1(const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m1(base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei16_v_i32m2(const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m2(base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei16_v_i32m4(const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m4(base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei16_v_i32m8(const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m8(base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei16_v_i64m1(const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m1(base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei16_v_i64m2(const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m2(base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei16_v_i64m4(const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m4(base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei16_v_i64m8(const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m8(base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16_v_u8mf8(const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf8(base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16_v_u8mf4(const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf4(base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16_v_u8mf2(const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf2(base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei16_v_u8m1(const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m1(base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei16_v_u8m2(const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m2(base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vluxei16_v_u8m4(const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m4(base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16_v_u16mf4(const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf4(base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16_v_u16mf2(const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf2(base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei16_v_u16m1(const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m1(base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei16_v_u16m2(const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m2(base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei16_v_u16m4(const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m4(base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vluxei16_v_u16m8(const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m8(base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16_v_u32mf2(const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32mf2(base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei16_v_u32m1(const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m1(base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei16_v_u32m2(const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m2(base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei16_v_u32m4(const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m4(base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei16_v_u32m8(const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m8(base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei16_v_u64m1(const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m1(base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei16_v_u64m2(const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m2(base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei16_v_u64m4(const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m4(base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei16_v_u64m8(const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m8(base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16_v_f32mf2(const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32mf2(base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16_v_f32m1(const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m1(base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16_v_f32m2(const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m2(base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16_v_f32m4(const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m4(base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16_v_f32m8(const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m8(base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16_v_f64m1(const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m1(base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16_v_f64m2(const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m2(base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16_v_f64m4(const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m4(base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16_v_f64m8(const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m8(base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_m-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_m-1.c
new file mode 100644
index 0000000..9edeae5
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_m-1.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei16_v_i8mf8_m(vbool64_t mask,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf8_m(mask,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei16_v_i8mf4_m(vbool32_t mask,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf4_m(mask,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei16_v_i8mf2_m(vbool16_t mask,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf2_m(mask,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei16_v_i8m1_m(vbool8_t mask,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m1_m(mask,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei16_v_i8m2_m(vbool4_t mask,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m2_m(mask,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vluxei16_v_i8m4_m(vbool2_t mask,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m4_m(mask,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei16_v_i16mf4_m(vbool64_t mask,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf4_m(mask,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei16_v_i16mf2_m(vbool32_t mask,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf2_m(mask,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei16_v_i16m1_m(vbool16_t mask,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m1_m(mask,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei16_v_i16m2_m(vbool8_t mask,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m2_m(mask,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei16_v_i16m4_m(vbool4_t mask,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m4_m(mask,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vluxei16_v_i16m8_m(vbool2_t mask,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m8_m(mask,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei16_v_i32mf2_m(vbool64_t mask,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32mf2_m(mask,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei16_v_i32m1_m(vbool32_t mask,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m1_m(mask,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei16_v_i32m2_m(vbool16_t mask,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m2_m(mask,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei16_v_i32m4_m(vbool8_t mask,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m4_m(mask,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei16_v_i32m8_m(vbool4_t mask,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m8_m(mask,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei16_v_i64m1_m(vbool64_t mask,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m1_m(mask,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei16_v_i64m2_m(vbool32_t mask,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m2_m(mask,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei16_v_i64m4_m(vbool16_t mask,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m4_m(mask,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei16_v_i64m8_m(vbool8_t mask,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m8_m(mask,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16_v_u8mf8_m(vbool64_t mask,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf8_m(mask,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16_v_u8mf4_m(vbool32_t mask,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf4_m(mask,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16_v_u8mf2_m(vbool16_t mask,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf2_m(mask,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei16_v_u8m1_m(vbool8_t mask,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m1_m(mask,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei16_v_u8m2_m(vbool4_t mask,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m2_m(mask,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vluxei16_v_u8m4_m(vbool2_t mask,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m4_m(mask,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16_v_u16mf4_m(vbool64_t mask,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf4_m(mask,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16_v_u16mf2_m(vbool32_t mask,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf2_m(mask,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei16_v_u16m1_m(vbool16_t mask,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m1_m(mask,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei16_v_u16m2_m(vbool8_t mask,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m2_m(mask,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei16_v_u16m4_m(vbool4_t mask,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m4_m(mask,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vluxei16_v_u16m8_m(vbool2_t mask,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m8_m(mask,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16_v_u32mf2_m(vbool64_t mask,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32mf2_m(mask,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei16_v_u32m1_m(vbool32_t mask,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m1_m(mask,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei16_v_u32m2_m(vbool16_t mask,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m2_m(mask,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei16_v_u32m4_m(vbool8_t mask,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m4_m(mask,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei16_v_u32m8_m(vbool4_t mask,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m8_m(mask,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei16_v_u64m1_m(vbool64_t mask,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m1_m(mask,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei16_v_u64m2_m(vbool32_t mask,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m2_m(mask,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei16_v_u64m4_m(vbool16_t mask,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m4_m(mask,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei16_v_u64m8_m(vbool8_t mask,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m8_m(mask,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16_v_f32mf2_m(vbool64_t mask,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32mf2_m(mask,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16_v_f32m1_m(vbool32_t mask,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m1_m(mask,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16_v_f32m2_m(vbool16_t mask,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m2_m(mask,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16_v_f32m4_m(vbool8_t mask,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m4_m(mask,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16_v_f32m8_m(vbool4_t mask,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m8_m(mask,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16_v_f64m1_m(vbool64_t mask,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m1_m(mask,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16_v_f64m2_m(vbool32_t mask,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m2_m(mask,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16_v_f64m4_m(vbool16_t mask,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m4_m(mask,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16_v_f64m8_m(vbool8_t mask,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m8_m(mask,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_m-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_m-2.c
new file mode 100644
index 0000000..4596993
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_m-2.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei16_v_i8mf8_m(vbool64_t mask,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf8_m(mask,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei16_v_i8mf4_m(vbool32_t mask,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf4_m(mask,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei16_v_i8mf2_m(vbool16_t mask,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf2_m(mask,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei16_v_i8m1_m(vbool8_t mask,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m1_m(mask,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei16_v_i8m2_m(vbool4_t mask,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m2_m(mask,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vluxei16_v_i8m4_m(vbool2_t mask,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m4_m(mask,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei16_v_i16mf4_m(vbool64_t mask,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf4_m(mask,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei16_v_i16mf2_m(vbool32_t mask,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf2_m(mask,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei16_v_i16m1_m(vbool16_t mask,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m1_m(mask,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei16_v_i16m2_m(vbool8_t mask,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m2_m(mask,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei16_v_i16m4_m(vbool4_t mask,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m4_m(mask,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vluxei16_v_i16m8_m(vbool2_t mask,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m8_m(mask,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei16_v_i32mf2_m(vbool64_t mask,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32mf2_m(mask,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei16_v_i32m1_m(vbool32_t mask,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m1_m(mask,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei16_v_i32m2_m(vbool16_t mask,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m2_m(mask,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei16_v_i32m4_m(vbool8_t mask,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m4_m(mask,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei16_v_i32m8_m(vbool4_t mask,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m8_m(mask,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei16_v_i64m1_m(vbool64_t mask,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m1_m(mask,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei16_v_i64m2_m(vbool32_t mask,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m2_m(mask,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei16_v_i64m4_m(vbool16_t mask,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m4_m(mask,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei16_v_i64m8_m(vbool8_t mask,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m8_m(mask,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16_v_u8mf8_m(vbool64_t mask,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf8_m(mask,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16_v_u8mf4_m(vbool32_t mask,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf4_m(mask,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16_v_u8mf2_m(vbool16_t mask,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf2_m(mask,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei16_v_u8m1_m(vbool8_t mask,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m1_m(mask,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei16_v_u8m2_m(vbool4_t mask,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m2_m(mask,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vluxei16_v_u8m4_m(vbool2_t mask,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m4_m(mask,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16_v_u16mf4_m(vbool64_t mask,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf4_m(mask,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16_v_u16mf2_m(vbool32_t mask,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf2_m(mask,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei16_v_u16m1_m(vbool16_t mask,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m1_m(mask,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei16_v_u16m2_m(vbool8_t mask,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m2_m(mask,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei16_v_u16m4_m(vbool4_t mask,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m4_m(mask,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vluxei16_v_u16m8_m(vbool2_t mask,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m8_m(mask,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16_v_u32mf2_m(vbool64_t mask,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32mf2_m(mask,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei16_v_u32m1_m(vbool32_t mask,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m1_m(mask,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei16_v_u32m2_m(vbool16_t mask,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m2_m(mask,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei16_v_u32m4_m(vbool8_t mask,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m4_m(mask,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei16_v_u32m8_m(vbool4_t mask,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m8_m(mask,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei16_v_u64m1_m(vbool64_t mask,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m1_m(mask,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei16_v_u64m2_m(vbool32_t mask,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m2_m(mask,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei16_v_u64m4_m(vbool16_t mask,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m4_m(mask,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei16_v_u64m8_m(vbool8_t mask,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m8_m(mask,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16_v_f32mf2_m(vbool64_t mask,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32mf2_m(mask,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16_v_f32m1_m(vbool32_t mask,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m1_m(mask,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16_v_f32m2_m(vbool16_t mask,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m2_m(mask,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16_v_f32m4_m(vbool8_t mask,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m4_m(mask,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16_v_f32m8_m(vbool4_t mask,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m8_m(mask,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16_v_f64m1_m(vbool64_t mask,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m1_m(mask,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16_v_f64m2_m(vbool32_t mask,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m2_m(mask,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16_v_f64m4_m(vbool16_t mask,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m4_m(mask,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16_v_f64m8_m(vbool8_t mask,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m8_m(mask,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_m-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_m-3.c
new file mode 100644
index 0000000..5d4efab
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_m-3.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei16_v_i8mf8_m(vbool64_t mask,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf8_m(mask,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei16_v_i8mf4_m(vbool32_t mask,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf4_m(mask,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei16_v_i8mf2_m(vbool16_t mask,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf2_m(mask,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei16_v_i8m1_m(vbool8_t mask,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m1_m(mask,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei16_v_i8m2_m(vbool4_t mask,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m2_m(mask,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vluxei16_v_i8m4_m(vbool2_t mask,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m4_m(mask,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei16_v_i16mf4_m(vbool64_t mask,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf4_m(mask,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei16_v_i16mf2_m(vbool32_t mask,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf2_m(mask,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei16_v_i16m1_m(vbool16_t mask,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m1_m(mask,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei16_v_i16m2_m(vbool8_t mask,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m2_m(mask,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei16_v_i16m4_m(vbool4_t mask,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m4_m(mask,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vluxei16_v_i16m8_m(vbool2_t mask,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m8_m(mask,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei16_v_i32mf2_m(vbool64_t mask,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32mf2_m(mask,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei16_v_i32m1_m(vbool32_t mask,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m1_m(mask,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei16_v_i32m2_m(vbool16_t mask,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m2_m(mask,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei16_v_i32m4_m(vbool8_t mask,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m4_m(mask,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei16_v_i32m8_m(vbool4_t mask,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m8_m(mask,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei16_v_i64m1_m(vbool64_t mask,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m1_m(mask,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei16_v_i64m2_m(vbool32_t mask,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m2_m(mask,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei16_v_i64m4_m(vbool16_t mask,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m4_m(mask,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei16_v_i64m8_m(vbool8_t mask,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m8_m(mask,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16_v_u8mf8_m(vbool64_t mask,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf8_m(mask,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16_v_u8mf4_m(vbool32_t mask,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf4_m(mask,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16_v_u8mf2_m(vbool16_t mask,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf2_m(mask,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei16_v_u8m1_m(vbool8_t mask,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m1_m(mask,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei16_v_u8m2_m(vbool4_t mask,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m2_m(mask,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vluxei16_v_u8m4_m(vbool2_t mask,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m4_m(mask,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16_v_u16mf4_m(vbool64_t mask,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf4_m(mask,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16_v_u16mf2_m(vbool32_t mask,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf2_m(mask,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei16_v_u16m1_m(vbool16_t mask,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m1_m(mask,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei16_v_u16m2_m(vbool8_t mask,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m2_m(mask,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei16_v_u16m4_m(vbool4_t mask,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m4_m(mask,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vluxei16_v_u16m8_m(vbool2_t mask,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m8_m(mask,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16_v_u32mf2_m(vbool64_t mask,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32mf2_m(mask,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei16_v_u32m1_m(vbool32_t mask,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m1_m(mask,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei16_v_u32m2_m(vbool16_t mask,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m2_m(mask,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei16_v_u32m4_m(vbool8_t mask,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m4_m(mask,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei16_v_u32m8_m(vbool4_t mask,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m8_m(mask,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei16_v_u64m1_m(vbool64_t mask,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m1_m(mask,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei16_v_u64m2_m(vbool32_t mask,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m2_m(mask,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei16_v_u64m4_m(vbool16_t mask,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m4_m(mask,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei16_v_u64m8_m(vbool8_t mask,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m8_m(mask,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16_v_f32mf2_m(vbool64_t mask,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32mf2_m(mask,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16_v_f32m1_m(vbool32_t mask,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m1_m(mask,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16_v_f32m2_m(vbool16_t mask,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m2_m(mask,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16_v_f32m4_m(vbool8_t mask,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m4_m(mask,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16_v_f32m8_m(vbool4_t mask,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m8_m(mask,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16_v_f64m1_m(vbool64_t mask,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m1_m(mask,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16_v_f64m2_m(vbool32_t mask,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m2_m(mask,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16_v_f64m4_m(vbool16_t mask,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m4_m(mask,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16_v_f64m8_m(vbool8_t mask,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m8_m(mask,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_mu-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_mu-1.c
new file mode 100644
index 0000000..3ef775d
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_mu-1.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei16_v_i8mf8_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei16_v_i8mf4_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei16_v_i8mf2_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei16_v_i8m1_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei16_v_i8m2_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vluxei16_v_i8m4_mu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei16_v_i16mf4_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei16_v_i16mf2_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei16_v_i16m1_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei16_v_i16m2_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei16_v_i16m4_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vluxei16_v_i16m8_mu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei16_v_i32mf2_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei16_v_i32m1_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei16_v_i32m2_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei16_v_i32m4_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei16_v_i32m8_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei16_v_i64m1_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei16_v_i64m2_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei16_v_i64m4_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei16_v_i64m8_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16_v_u8mf8_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16_v_u8mf4_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16_v_u8mf2_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei16_v_u8m1_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei16_v_u8m2_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vluxei16_v_u8m4_mu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16_v_u16mf4_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16_v_u16mf2_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei16_v_u16m1_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei16_v_u16m2_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei16_v_u16m4_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vluxei16_v_u16m8_mu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16_v_u32mf2_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei16_v_u32m1_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei16_v_u32m2_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei16_v_u32m4_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei16_v_u32m8_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei16_v_u64m1_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei16_v_u64m2_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei16_v_u64m4_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei16_v_u64m8_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16_v_f32mf2_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16_v_f32m1_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16_v_f32m2_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16_v_f32m4_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16_v_f32m8_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16_v_f64m1_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16_v_f64m2_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16_v_f64m4_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16_v_f64m8_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_mu-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_mu-2.c
new file mode 100644
index 0000000..ccaee0b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_mu-2.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei16_v_i8mf8_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei16_v_i8mf4_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei16_v_i8mf2_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei16_v_i8m1_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei16_v_i8m2_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vluxei16_v_i8m4_mu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei16_v_i16mf4_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei16_v_i16mf2_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei16_v_i16m1_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei16_v_i16m2_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei16_v_i16m4_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vluxei16_v_i16m8_mu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei16_v_i32mf2_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei16_v_i32m1_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei16_v_i32m2_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei16_v_i32m4_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei16_v_i32m8_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei16_v_i64m1_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei16_v_i64m2_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei16_v_i64m4_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei16_v_i64m8_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16_v_u8mf8_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16_v_u8mf4_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16_v_u8mf2_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei16_v_u8m1_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei16_v_u8m2_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vluxei16_v_u8m4_mu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16_v_u16mf4_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16_v_u16mf2_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei16_v_u16m1_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei16_v_u16m2_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei16_v_u16m4_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vluxei16_v_u16m8_mu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16_v_u32mf2_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei16_v_u32m1_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei16_v_u32m2_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei16_v_u32m4_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei16_v_u32m8_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei16_v_u64m1_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei16_v_u64m2_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei16_v_u64m4_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei16_v_u64m8_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16_v_f32mf2_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16_v_f32m1_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16_v_f32m2_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16_v_f32m4_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16_v_f32m8_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16_v_f64m1_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16_v_f64m2_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16_v_f64m4_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16_v_f64m8_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m8_mu(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_mu-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_mu-3.c
new file mode 100644
index 0000000..11ca0da
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_mu-3.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei16_v_i8mf8_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei16_v_i8mf4_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei16_v_i8mf2_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei16_v_i8m1_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei16_v_i8m2_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vluxei16_v_i8m4_mu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei16_v_i16mf4_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei16_v_i16mf2_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei16_v_i16m1_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei16_v_i16m2_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei16_v_i16m4_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vluxei16_v_i16m8_mu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei16_v_i32mf2_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei16_v_i32m1_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei16_v_i32m2_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei16_v_i32m4_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei16_v_i32m8_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei16_v_i64m1_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei16_v_i64m2_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei16_v_i64m4_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei16_v_i64m8_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16_v_u8mf8_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16_v_u8mf4_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16_v_u8mf2_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei16_v_u8m1_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei16_v_u8m2_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vluxei16_v_u8m4_mu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16_v_u16mf4_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16_v_u16mf2_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei16_v_u16m1_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei16_v_u16m2_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei16_v_u16m4_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vluxei16_v_u16m8_mu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16_v_u32mf2_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei16_v_u32m1_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei16_v_u32m2_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei16_v_u32m4_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei16_v_u32m8_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei16_v_u64m1_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei16_v_u64m2_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei16_v_u64m4_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei16_v_u64m8_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16_v_f32mf2_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16_v_f32m1_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16_v_f32m2_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16_v_f32m4_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16_v_f32m8_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16_v_f64m1_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16_v_f64m2_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16_v_f64m4_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16_v_f64m8_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m8_mu(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_tu-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_tu-1.c
new file mode 100644
index 0000000..da45de9
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_tu-1.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei16_v_i8mf8_tu(vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf8_tu(merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei16_v_i8mf4_tu(vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf4_tu(merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei16_v_i8mf2_tu(vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf2_tu(merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei16_v_i8m1_tu(vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m1_tu(merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei16_v_i8m2_tu(vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m2_tu(merge,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vluxei16_v_i8m4_tu(vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m4_tu(merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei16_v_i16mf4_tu(vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf4_tu(merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei16_v_i16mf2_tu(vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf2_tu(merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei16_v_i16m1_tu(vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m1_tu(merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei16_v_i16m2_tu(vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m2_tu(merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei16_v_i16m4_tu(vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m4_tu(merge,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vluxei16_v_i16m8_tu(vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m8_tu(merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei16_v_i32mf2_tu(vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32mf2_tu(merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei16_v_i32m1_tu(vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m1_tu(merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei16_v_i32m2_tu(vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m2_tu(merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei16_v_i32m4_tu(vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m4_tu(merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei16_v_i32m8_tu(vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m8_tu(merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei16_v_i64m1_tu(vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m1_tu(merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei16_v_i64m2_tu(vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m2_tu(merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei16_v_i64m4_tu(vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m4_tu(merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei16_v_i64m8_tu(vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m8_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16_v_u8mf8_tu(vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf8_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16_v_u8mf4_tu(vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf4_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16_v_u8mf2_tu(vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf2_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei16_v_u8m1_tu(vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m1_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei16_v_u8m2_tu(vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m2_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vluxei16_v_u8m4_tu(vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m4_tu(merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16_v_u16mf4_tu(vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf4_tu(merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16_v_u16mf2_tu(vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf2_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei16_v_u16m1_tu(vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m1_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei16_v_u16m2_tu(vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m2_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei16_v_u16m4_tu(vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m4_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vluxei16_v_u16m8_tu(vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m8_tu(merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16_v_u32mf2_tu(vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32mf2_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei16_v_u32m1_tu(vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m1_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei16_v_u32m2_tu(vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m2_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei16_v_u32m4_tu(vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m4_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei16_v_u32m8_tu(vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m8_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei16_v_u64m1_tu(vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m1_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei16_v_u64m2_tu(vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m2_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei16_v_u64m4_tu(vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m4_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei16_v_u64m8_tu(vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m8_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16_v_f32mf2_tu(vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32mf2_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16_v_f32m1_tu(vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m1_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16_v_f32m2_tu(vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m2_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16_v_f32m4_tu(vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m4_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16_v_f32m8_tu(vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m8_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16_v_f64m1_tu(vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m1_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16_v_f64m2_tu(vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m2_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16_v_f64m4_tu(vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m4_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16_v_f64m8_tu(vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m8_tu(merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_tu-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_tu-2.c
new file mode 100644
index 0000000..9845f9d
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_tu-2.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei16_v_i8mf8_tu(vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf8_tu(merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei16_v_i8mf4_tu(vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf4_tu(merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei16_v_i8mf2_tu(vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf2_tu(merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei16_v_i8m1_tu(vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m1_tu(merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei16_v_i8m2_tu(vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m2_tu(merge,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vluxei16_v_i8m4_tu(vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m4_tu(merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei16_v_i16mf4_tu(vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf4_tu(merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei16_v_i16mf2_tu(vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf2_tu(merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei16_v_i16m1_tu(vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m1_tu(merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei16_v_i16m2_tu(vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m2_tu(merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei16_v_i16m4_tu(vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m4_tu(merge,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vluxei16_v_i16m8_tu(vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m8_tu(merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei16_v_i32mf2_tu(vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32mf2_tu(merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei16_v_i32m1_tu(vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m1_tu(merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei16_v_i32m2_tu(vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m2_tu(merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei16_v_i32m4_tu(vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m4_tu(merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei16_v_i32m8_tu(vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m8_tu(merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei16_v_i64m1_tu(vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m1_tu(merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei16_v_i64m2_tu(vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m2_tu(merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei16_v_i64m4_tu(vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m4_tu(merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei16_v_i64m8_tu(vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m8_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16_v_u8mf8_tu(vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf8_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16_v_u8mf4_tu(vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf4_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16_v_u8mf2_tu(vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf2_tu(merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei16_v_u8m1_tu(vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m1_tu(merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei16_v_u8m2_tu(vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m2_tu(merge,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vluxei16_v_u8m4_tu(vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m4_tu(merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16_v_u16mf4_tu(vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf4_tu(merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16_v_u16mf2_tu(vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf2_tu(merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei16_v_u16m1_tu(vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m1_tu(merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei16_v_u16m2_tu(vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m2_tu(merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei16_v_u16m4_tu(vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m4_tu(merge,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vluxei16_v_u16m8_tu(vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m8_tu(merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16_v_u32mf2_tu(vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32mf2_tu(merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei16_v_u32m1_tu(vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m1_tu(merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei16_v_u32m2_tu(vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m2_tu(merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei16_v_u32m4_tu(vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m4_tu(merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei16_v_u32m8_tu(vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m8_tu(merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei16_v_u64m1_tu(vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m1_tu(merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei16_v_u64m2_tu(vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m2_tu(merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei16_v_u64m4_tu(vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m4_tu(merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei16_v_u64m8_tu(vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m8_tu(merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16_v_f32mf2_tu(vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32mf2_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16_v_f32m1_tu(vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m1_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16_v_f32m2_tu(vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m2_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16_v_f32m4_tu(vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m4_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16_v_f32m8_tu(vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m8_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16_v_f64m1_tu(vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m1_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16_v_f64m2_tu(vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m2_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16_v_f64m4_tu(vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m4_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16_v_f64m8_tu(vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m8_tu(merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_tu-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_tu-3.c
new file mode 100644
index 0000000..5f4ec69
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_tu-3.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei16_v_i8mf8_tu(vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf8_tu(merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei16_v_i8mf4_tu(vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf4_tu(merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei16_v_i8mf2_tu(vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf2_tu(merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei16_v_i8m1_tu(vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m1_tu(merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei16_v_i8m2_tu(vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m2_tu(merge,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vluxei16_v_i8m4_tu(vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m4_tu(merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei16_v_i16mf4_tu(vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf4_tu(merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei16_v_i16mf2_tu(vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf2_tu(merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei16_v_i16m1_tu(vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m1_tu(merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei16_v_i16m2_tu(vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m2_tu(merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei16_v_i16m4_tu(vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m4_tu(merge,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vluxei16_v_i16m8_tu(vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m8_tu(merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei16_v_i32mf2_tu(vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32mf2_tu(merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei16_v_i32m1_tu(vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m1_tu(merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei16_v_i32m2_tu(vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m2_tu(merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei16_v_i32m4_tu(vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m4_tu(merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei16_v_i32m8_tu(vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m8_tu(merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei16_v_i64m1_tu(vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m1_tu(merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei16_v_i64m2_tu(vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m2_tu(merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei16_v_i64m4_tu(vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m4_tu(merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei16_v_i64m8_tu(vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m8_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16_v_u8mf8_tu(vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf8_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16_v_u8mf4_tu(vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf4_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16_v_u8mf2_tu(vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf2_tu(merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei16_v_u8m1_tu(vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m1_tu(merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei16_v_u8m2_tu(vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m2_tu(merge,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vluxei16_v_u8m4_tu(vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m4_tu(merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16_v_u16mf4_tu(vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf4_tu(merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16_v_u16mf2_tu(vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf2_tu(merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei16_v_u16m1_tu(vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m1_tu(merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei16_v_u16m2_tu(vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m2_tu(merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei16_v_u16m4_tu(vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m4_tu(merge,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vluxei16_v_u16m8_tu(vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m8_tu(merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16_v_u32mf2_tu(vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32mf2_tu(merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei16_v_u32m1_tu(vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m1_tu(merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei16_v_u32m2_tu(vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m2_tu(merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei16_v_u32m4_tu(vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m4_tu(merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei16_v_u32m8_tu(vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m8_tu(merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei16_v_u64m1_tu(vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m1_tu(merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei16_v_u64m2_tu(vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m2_tu(merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei16_v_u64m4_tu(vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m4_tu(merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei16_v_u64m8_tu(vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m8_tu(merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16_v_f32mf2_tu(vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32mf2_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16_v_f32m1_tu(vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m1_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16_v_f32m2_tu(vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m2_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16_v_f32m4_tu(vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m4_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16_v_f32m8_tu(vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m8_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16_v_f64m1_tu(vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m1_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16_v_f64m2_tu(vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m2_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16_v_f64m4_tu(vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m4_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16_v_f64m8_tu(vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m8_tu(merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_tum-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_tum-1.c
new file mode 100644
index 0000000..9d3e084
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_tum-1.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei16_v_i8mf8_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei16_v_i8mf4_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei16_v_i8mf2_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei16_v_i8m1_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei16_v_i8m2_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vluxei16_v_i8m4_tum(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei16_v_i16mf4_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei16_v_i16mf2_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei16_v_i16m1_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei16_v_i16m2_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei16_v_i16m4_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vluxei16_v_i16m8_tum(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei16_v_i32mf2_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei16_v_i32m1_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei16_v_i32m2_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei16_v_i32m4_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei16_v_i32m8_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei16_v_i64m1_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei16_v_i64m2_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei16_v_i64m4_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei16_v_i64m8_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16_v_u8mf8_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16_v_u8mf4_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16_v_u8mf2_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei16_v_u8m1_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei16_v_u8m2_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vluxei16_v_u8m4_tum(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16_v_u16mf4_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16_v_u16mf2_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei16_v_u16m1_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei16_v_u16m2_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei16_v_u16m4_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vluxei16_v_u16m8_tum(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16_v_u32mf2_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei16_v_u32m1_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei16_v_u32m2_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei16_v_u32m4_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei16_v_u32m8_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei16_v_u64m1_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei16_v_u64m2_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei16_v_u64m4_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei16_v_u64m8_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16_v_f32mf2_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16_v_f32m1_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16_v_f32m2_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16_v_f32m4_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16_v_f32m8_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16_v_f64m1_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16_v_f64m2_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16_v_f64m4_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16_v_f64m8_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_tum-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_tum-2.c
new file mode 100644
index 0000000..4f9ae9d
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_tum-2.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei16_v_i8mf8_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei16_v_i8mf4_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei16_v_i8mf2_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei16_v_i8m1_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei16_v_i8m2_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vluxei16_v_i8m4_tum(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei16_v_i16mf4_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei16_v_i16mf2_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei16_v_i16m1_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei16_v_i16m2_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei16_v_i16m4_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vluxei16_v_i16m8_tum(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei16_v_i32mf2_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei16_v_i32m1_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei16_v_i32m2_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei16_v_i32m4_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei16_v_i32m8_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei16_v_i64m1_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei16_v_i64m2_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei16_v_i64m4_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei16_v_i64m8_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16_v_u8mf8_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16_v_u8mf4_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16_v_u8mf2_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei16_v_u8m1_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei16_v_u8m2_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vluxei16_v_u8m4_tum(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16_v_u16mf4_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16_v_u16mf2_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei16_v_u16m1_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei16_v_u16m2_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei16_v_u16m4_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vluxei16_v_u16m8_tum(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16_v_u32mf2_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei16_v_u32m1_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei16_v_u32m2_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei16_v_u32m4_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei16_v_u32m8_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei16_v_u64m1_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei16_v_u64m2_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei16_v_u64m4_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei16_v_u64m8_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16_v_f32mf2_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16_v_f32m1_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16_v_f32m2_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16_v_f32m4_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16_v_f32m8_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16_v_f64m1_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16_v_f64m2_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16_v_f64m4_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16_v_f64m8_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m8_tum(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_tum-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_tum-3.c
new file mode 100644
index 0000000..daa314c
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_tum-3.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei16_v_i8mf8_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei16_v_i8mf4_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei16_v_i8mf2_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei16_v_i8m1_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei16_v_i8m2_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vluxei16_v_i8m4_tum(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei16_v_i16mf4_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei16_v_i16mf2_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei16_v_i16m1_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei16_v_i16m2_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei16_v_i16m4_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vluxei16_v_i16m8_tum(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei16_v_i32mf2_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei16_v_i32m1_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei16_v_i32m2_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei16_v_i32m4_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei16_v_i32m8_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei16_v_i64m1_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei16_v_i64m2_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei16_v_i64m4_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei16_v_i64m8_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16_v_u8mf8_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16_v_u8mf4_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16_v_u8mf2_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei16_v_u8m1_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei16_v_u8m2_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vluxei16_v_u8m4_tum(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16_v_u16mf4_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16_v_u16mf2_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei16_v_u16m1_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei16_v_u16m2_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei16_v_u16m4_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vluxei16_v_u16m8_tum(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16_v_u32mf2_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei16_v_u32m1_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei16_v_u32m2_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei16_v_u32m4_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei16_v_u32m8_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei16_v_u64m1_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei16_v_u64m2_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei16_v_u64m4_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei16_v_u64m8_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16_v_f32mf2_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16_v_f32m1_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16_v_f32m2_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16_v_f32m4_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16_v_f32m8_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16_v_f64m1_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16_v_f64m2_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16_v_f64m4_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16_v_f64m8_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m8_tum(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_tumu-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_tumu-1.c
new file mode 100644
index 0000000..c8c9fd8
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_tumu-1.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei16_v_i8mf8_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei16_v_i8mf4_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei16_v_i8mf2_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei16_v_i8m1_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei16_v_i8m2_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vluxei16_v_i8m4_tumu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei16_v_i16mf4_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei16_v_i16mf2_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei16_v_i16m1_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei16_v_i16m2_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei16_v_i16m4_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vluxei16_v_i16m8_tumu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei16_v_i32mf2_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei16_v_i32m1_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei16_v_i32m2_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei16_v_i32m4_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei16_v_i32m8_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei16_v_i64m1_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei16_v_i64m2_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei16_v_i64m4_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei16_v_i64m8_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16_v_u8mf8_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16_v_u8mf4_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16_v_u8mf2_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei16_v_u8m1_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei16_v_u8m2_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vluxei16_v_u8m4_tumu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16_v_u16mf4_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16_v_u16mf2_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei16_v_u16m1_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei16_v_u16m2_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei16_v_u16m4_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vluxei16_v_u16m8_tumu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16_v_u32mf2_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei16_v_u32m1_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei16_v_u32m2_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei16_v_u32m4_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei16_v_u32m8_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei16_v_u64m1_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei16_v_u64m2_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei16_v_u64m4_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei16_v_u64m8_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16_v_f32mf2_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16_v_f32m1_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16_v_f32m2_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16_v_f32m4_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16_v_f32m8_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16_v_f64m1_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16_v_f64m2_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16_v_f64m4_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16_v_f64m8_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_tumu-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_tumu-2.c
new file mode 100644
index 0000000..86c0d56
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_tumu-2.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei16_v_i8mf8_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei16_v_i8mf4_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei16_v_i8mf2_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei16_v_i8m1_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei16_v_i8m2_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vluxei16_v_i8m4_tumu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei16_v_i16mf4_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei16_v_i16mf2_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei16_v_i16m1_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei16_v_i16m2_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei16_v_i16m4_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vluxei16_v_i16m8_tumu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei16_v_i32mf2_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei16_v_i32m1_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei16_v_i32m2_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei16_v_i32m4_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei16_v_i32m8_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei16_v_i64m1_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei16_v_i64m2_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei16_v_i64m4_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei16_v_i64m8_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16_v_u8mf8_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16_v_u8mf4_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16_v_u8mf2_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei16_v_u8m1_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei16_v_u8m2_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vluxei16_v_u8m4_tumu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16_v_u16mf4_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16_v_u16mf2_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei16_v_u16m1_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei16_v_u16m2_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei16_v_u16m4_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vluxei16_v_u16m8_tumu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16_v_u32mf2_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei16_v_u32m1_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei16_v_u32m2_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei16_v_u32m4_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei16_v_u32m8_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei16_v_u64m1_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei16_v_u64m2_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei16_v_u64m4_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei16_v_u64m8_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16_v_f32mf2_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16_v_f32m1_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16_v_f32m2_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16_v_f32m4_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16_v_f32m8_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16_v_f64m1_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16_v_f64m2_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16_v_f64m4_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16_v_f64m8_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_tumu-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_tumu-3.c
new file mode 100644
index 0000000..661ec43
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei16_v_tumu-3.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei16_v_i8mf8_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei16_v_i8mf4_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei16_v_i8mf2_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei16_v_i8m1_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei16_v_i8m2_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vluxei16_v_i8m4_tumu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i8m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei16_v_i16mf4_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei16_v_i16mf2_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei16_v_i16m1_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei16_v_i16m2_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei16_v_i16m4_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vluxei16_v_i16m8_tumu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i16m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei16_v_i32mf2_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei16_v_i32m1_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei16_v_i32m2_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei16_v_i32m4_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei16_v_i32m8_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i32m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei16_v_i64m1_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei16_v_i64m2_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei16_v_i64m4_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei16_v_i64m8_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_i64m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei16_v_u8mf8_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei16_v_u8mf4_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei16_v_u8mf2_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei16_v_u8m1_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei16_v_u8m2_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vluxei16_v_u8m4_tumu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u8m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei16_v_u16mf4_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei16_v_u16mf2_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei16_v_u16m1_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei16_v_u16m2_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei16_v_u16m4_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vluxei16_v_u16m8_tumu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint16m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u16m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei16_v_u32mf2_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei16_v_u32m1_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei16_v_u32m2_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei16_v_u32m4_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei16_v_u32m8_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u32m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei16_v_u64m1_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei16_v_u64m2_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei16_v_u64m4_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei16_v_u64m8_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_u64m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei16_v_f32mf2_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei16_v_f32m1_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei16_v_f32m2_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei16_v_f32m4_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei16_v_f32m8_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint16m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f32m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei16_v_f64m1_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint16mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei16_v_f64m2_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint16mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei16_v_f64m4_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint16m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei16_v_f64m8_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint16m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei16_v_f64m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vluxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v-1.c
new file mode 100644
index 0000000..2542686
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v-1.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei32_v_i8mf8(const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf8(base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei32_v_i8mf4(const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf4(base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei32_v_i8mf2(const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf2(base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei32_v_i8m1(const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m1(base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei32_v_i8m2(const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m2(base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei32_v_i16mf4(const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf4(base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei32_v_i16mf2(const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf2(base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei32_v_i16m1(const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m1(base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei32_v_i16m2(const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m2(base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei32_v_i16m4(const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m4(base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei32_v_i32mf2(const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32mf2(base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei32_v_i32m1(const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m1(base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei32_v_i32m2(const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m2(base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei32_v_i32m4(const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m4(base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei32_v_i32m8(const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m8(base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei32_v_i64m1(const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m1(base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei32_v_i64m2(const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m2(base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei32_v_i64m4(const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m4(base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei32_v_i64m8(const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m8(base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32_v_u8mf8(const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf8(base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32_v_u8mf4(const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf4(base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32_v_u8mf2(const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf2(base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei32_v_u8m1(const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m1(base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei32_v_u8m2(const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m2(base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32_v_u16mf4(const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf4(base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32_v_u16mf2(const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf2(base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei32_v_u16m1(const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m1(base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei32_v_u16m2(const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m2(base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei32_v_u16m4(const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m4(base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32_v_u32mf2(const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32mf2(base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei32_v_u32m1(const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m1(base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei32_v_u32m2(const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m2(base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei32_v_u32m4(const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m4(base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei32_v_u32m8(const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m8(base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei32_v_u64m1(const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m1(base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei32_v_u64m2(const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m2(base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei32_v_u64m4(const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m4(base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei32_v_u64m8(const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m8(base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32_v_f32mf2(const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32mf2(base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32_v_f32m1(const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m1(base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32_v_f32m2(const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m2(base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32_v_f32m4(const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m4(base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32_v_f32m8(const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m8(base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32_v_f64m1(const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m1(base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32_v_f64m2(const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m2(base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32_v_f64m4(const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m4(base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32_v_f64m8(const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m8(base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v-2.c
new file mode 100644
index 0000000..f49a8d8
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v-2.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei32_v_i8mf8(const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf8(base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei32_v_i8mf4(const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf4(base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei32_v_i8mf2(const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf2(base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei32_v_i8m1(const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m1(base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei32_v_i8m2(const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m2(base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei32_v_i16mf4(const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf4(base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei32_v_i16mf2(const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf2(base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei32_v_i16m1(const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m1(base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei32_v_i16m2(const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m2(base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei32_v_i16m4(const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m4(base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei32_v_i32mf2(const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32mf2(base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei32_v_i32m1(const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m1(base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei32_v_i32m2(const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m2(base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei32_v_i32m4(const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m4(base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei32_v_i32m8(const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m8(base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei32_v_i64m1(const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m1(base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei32_v_i64m2(const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m2(base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei32_v_i64m4(const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m4(base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei32_v_i64m8(const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m8(base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32_v_u8mf8(const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf8(base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32_v_u8mf4(const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf4(base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32_v_u8mf2(const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf2(base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei32_v_u8m1(const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m1(base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei32_v_u8m2(const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m2(base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32_v_u16mf4(const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf4(base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32_v_u16mf2(const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf2(base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei32_v_u16m1(const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m1(base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei32_v_u16m2(const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m2(base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei32_v_u16m4(const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m4(base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32_v_u32mf2(const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32mf2(base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei32_v_u32m1(const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m1(base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei32_v_u32m2(const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m2(base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei32_v_u32m4(const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m4(base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei32_v_u32m8(const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m8(base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei32_v_u64m1(const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m1(base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei32_v_u64m2(const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m2(base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei32_v_u64m4(const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m4(base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei32_v_u64m8(const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m8(base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32_v_f32mf2(const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32mf2(base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32_v_f32m1(const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m1(base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32_v_f32m2(const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m2(base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32_v_f32m4(const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m4(base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32_v_f32m8(const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m8(base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32_v_f64m1(const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m1(base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32_v_f64m2(const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m2(base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32_v_f64m4(const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m4(base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32_v_f64m8(const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m8(base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v-3.c
new file mode 100644
index 0000000..945b70c
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v-3.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei32_v_i8mf8(const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf8(base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei32_v_i8mf4(const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf4(base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei32_v_i8mf2(const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf2(base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei32_v_i8m1(const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m1(base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei32_v_i8m2(const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m2(base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei32_v_i16mf4(const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf4(base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei32_v_i16mf2(const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf2(base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei32_v_i16m1(const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m1(base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei32_v_i16m2(const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m2(base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei32_v_i16m4(const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m4(base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei32_v_i32mf2(const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32mf2(base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei32_v_i32m1(const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m1(base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei32_v_i32m2(const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m2(base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei32_v_i32m4(const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m4(base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei32_v_i32m8(const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m8(base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei32_v_i64m1(const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m1(base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei32_v_i64m2(const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m2(base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei32_v_i64m4(const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m4(base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei32_v_i64m8(const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m8(base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32_v_u8mf8(const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf8(base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32_v_u8mf4(const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf4(base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32_v_u8mf2(const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf2(base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei32_v_u8m1(const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m1(base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei32_v_u8m2(const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m2(base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32_v_u16mf4(const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf4(base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32_v_u16mf2(const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf2(base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei32_v_u16m1(const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m1(base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei32_v_u16m2(const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m2(base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei32_v_u16m4(const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m4(base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32_v_u32mf2(const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32mf2(base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei32_v_u32m1(const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m1(base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei32_v_u32m2(const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m2(base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei32_v_u32m4(const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m4(base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei32_v_u32m8(const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m8(base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei32_v_u64m1(const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m1(base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei32_v_u64m2(const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m2(base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei32_v_u64m4(const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m4(base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei32_v_u64m8(const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m8(base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32_v_f32mf2(const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32mf2(base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32_v_f32m1(const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m1(base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32_v_f32m2(const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m2(base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32_v_f32m4(const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m4(base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32_v_f32m8(const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m8(base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32_v_f64m1(const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m1(base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32_v_f64m2(const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m2(base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32_v_f64m4(const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m4(base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32_v_f64m8(const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m8(base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_m-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_m-1.c
new file mode 100644
index 0000000..86a4fbd
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_m-1.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei32_v_i8mf8_m(vbool64_t mask,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf8_m(mask,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei32_v_i8mf4_m(vbool32_t mask,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf4_m(mask,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei32_v_i8mf2_m(vbool16_t mask,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf2_m(mask,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei32_v_i8m1_m(vbool8_t mask,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m1_m(mask,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei32_v_i8m2_m(vbool4_t mask,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m2_m(mask,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei32_v_i16mf4_m(vbool64_t mask,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf4_m(mask,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei32_v_i16mf2_m(vbool32_t mask,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf2_m(mask,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei32_v_i16m1_m(vbool16_t mask,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m1_m(mask,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei32_v_i16m2_m(vbool8_t mask,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m2_m(mask,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei32_v_i16m4_m(vbool4_t mask,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m4_m(mask,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei32_v_i32mf2_m(vbool64_t mask,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32mf2_m(mask,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei32_v_i32m1_m(vbool32_t mask,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m1_m(mask,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei32_v_i32m2_m(vbool16_t mask,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m2_m(mask,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei32_v_i32m4_m(vbool8_t mask,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m4_m(mask,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei32_v_i32m8_m(vbool4_t mask,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m8_m(mask,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei32_v_i64m1_m(vbool64_t mask,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m1_m(mask,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei32_v_i64m2_m(vbool32_t mask,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m2_m(mask,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei32_v_i64m4_m(vbool16_t mask,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m4_m(mask,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei32_v_i64m8_m(vbool8_t mask,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m8_m(mask,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32_v_u8mf8_m(vbool64_t mask,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf8_m(mask,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32_v_u8mf4_m(vbool32_t mask,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf4_m(mask,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32_v_u8mf2_m(vbool16_t mask,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf2_m(mask,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei32_v_u8m1_m(vbool8_t mask,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m1_m(mask,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei32_v_u8m2_m(vbool4_t mask,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m2_m(mask,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32_v_u16mf4_m(vbool64_t mask,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf4_m(mask,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32_v_u16mf2_m(vbool32_t mask,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf2_m(mask,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei32_v_u16m1_m(vbool16_t mask,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m1_m(mask,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei32_v_u16m2_m(vbool8_t mask,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m2_m(mask,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei32_v_u16m4_m(vbool4_t mask,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m4_m(mask,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32_v_u32mf2_m(vbool64_t mask,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32mf2_m(mask,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei32_v_u32m1_m(vbool32_t mask,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m1_m(mask,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei32_v_u32m2_m(vbool16_t mask,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m2_m(mask,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei32_v_u32m4_m(vbool8_t mask,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m4_m(mask,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei32_v_u32m8_m(vbool4_t mask,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m8_m(mask,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei32_v_u64m1_m(vbool64_t mask,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m1_m(mask,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei32_v_u64m2_m(vbool32_t mask,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m2_m(mask,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei32_v_u64m4_m(vbool16_t mask,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m4_m(mask,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei32_v_u64m8_m(vbool8_t mask,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m8_m(mask,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32_v_f32mf2_m(vbool64_t mask,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32mf2_m(mask,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32_v_f32m1_m(vbool32_t mask,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m1_m(mask,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32_v_f32m2_m(vbool16_t mask,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m2_m(mask,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32_v_f32m4_m(vbool8_t mask,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m4_m(mask,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32_v_f32m8_m(vbool4_t mask,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m8_m(mask,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32_v_f64m1_m(vbool64_t mask,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m1_m(mask,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32_v_f64m2_m(vbool32_t mask,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m2_m(mask,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32_v_f64m4_m(vbool16_t mask,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m4_m(mask,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32_v_f64m8_m(vbool8_t mask,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m8_m(mask,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_m-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_m-2.c
new file mode 100644
index 0000000..02df1ba
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_m-2.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei32_v_i8mf8_m(vbool64_t mask,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf8_m(mask,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei32_v_i8mf4_m(vbool32_t mask,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf4_m(mask,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei32_v_i8mf2_m(vbool16_t mask,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf2_m(mask,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei32_v_i8m1_m(vbool8_t mask,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m1_m(mask,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei32_v_i8m2_m(vbool4_t mask,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m2_m(mask,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei32_v_i16mf4_m(vbool64_t mask,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf4_m(mask,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei32_v_i16mf2_m(vbool32_t mask,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf2_m(mask,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei32_v_i16m1_m(vbool16_t mask,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m1_m(mask,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei32_v_i16m2_m(vbool8_t mask,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m2_m(mask,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei32_v_i16m4_m(vbool4_t mask,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m4_m(mask,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei32_v_i32mf2_m(vbool64_t mask,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32mf2_m(mask,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei32_v_i32m1_m(vbool32_t mask,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m1_m(mask,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei32_v_i32m2_m(vbool16_t mask,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m2_m(mask,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei32_v_i32m4_m(vbool8_t mask,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m4_m(mask,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei32_v_i32m8_m(vbool4_t mask,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m8_m(mask,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei32_v_i64m1_m(vbool64_t mask,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m1_m(mask,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei32_v_i64m2_m(vbool32_t mask,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m2_m(mask,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei32_v_i64m4_m(vbool16_t mask,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m4_m(mask,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei32_v_i64m8_m(vbool8_t mask,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m8_m(mask,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32_v_u8mf8_m(vbool64_t mask,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf8_m(mask,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32_v_u8mf4_m(vbool32_t mask,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf4_m(mask,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32_v_u8mf2_m(vbool16_t mask,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf2_m(mask,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei32_v_u8m1_m(vbool8_t mask,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m1_m(mask,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei32_v_u8m2_m(vbool4_t mask,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m2_m(mask,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32_v_u16mf4_m(vbool64_t mask,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf4_m(mask,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32_v_u16mf2_m(vbool32_t mask,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf2_m(mask,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei32_v_u16m1_m(vbool16_t mask,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m1_m(mask,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei32_v_u16m2_m(vbool8_t mask,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m2_m(mask,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei32_v_u16m4_m(vbool4_t mask,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m4_m(mask,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32_v_u32mf2_m(vbool64_t mask,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32mf2_m(mask,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei32_v_u32m1_m(vbool32_t mask,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m1_m(mask,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei32_v_u32m2_m(vbool16_t mask,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m2_m(mask,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei32_v_u32m4_m(vbool8_t mask,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m4_m(mask,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei32_v_u32m8_m(vbool4_t mask,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m8_m(mask,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei32_v_u64m1_m(vbool64_t mask,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m1_m(mask,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei32_v_u64m2_m(vbool32_t mask,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m2_m(mask,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei32_v_u64m4_m(vbool16_t mask,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m4_m(mask,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei32_v_u64m8_m(vbool8_t mask,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m8_m(mask,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32_v_f32mf2_m(vbool64_t mask,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32mf2_m(mask,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32_v_f32m1_m(vbool32_t mask,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m1_m(mask,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32_v_f32m2_m(vbool16_t mask,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m2_m(mask,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32_v_f32m4_m(vbool8_t mask,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m4_m(mask,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32_v_f32m8_m(vbool4_t mask,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m8_m(mask,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32_v_f64m1_m(vbool64_t mask,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m1_m(mask,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32_v_f64m2_m(vbool32_t mask,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m2_m(mask,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32_v_f64m4_m(vbool16_t mask,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m4_m(mask,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32_v_f64m8_m(vbool8_t mask,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m8_m(mask,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_m-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_m-3.c
new file mode 100644
index 0000000..976ac99
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_m-3.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei32_v_i8mf8_m(vbool64_t mask,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf8_m(mask,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei32_v_i8mf4_m(vbool32_t mask,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf4_m(mask,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei32_v_i8mf2_m(vbool16_t mask,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf2_m(mask,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei32_v_i8m1_m(vbool8_t mask,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m1_m(mask,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei32_v_i8m2_m(vbool4_t mask,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m2_m(mask,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei32_v_i16mf4_m(vbool64_t mask,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf4_m(mask,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei32_v_i16mf2_m(vbool32_t mask,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf2_m(mask,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei32_v_i16m1_m(vbool16_t mask,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m1_m(mask,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei32_v_i16m2_m(vbool8_t mask,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m2_m(mask,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei32_v_i16m4_m(vbool4_t mask,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m4_m(mask,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei32_v_i32mf2_m(vbool64_t mask,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32mf2_m(mask,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei32_v_i32m1_m(vbool32_t mask,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m1_m(mask,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei32_v_i32m2_m(vbool16_t mask,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m2_m(mask,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei32_v_i32m4_m(vbool8_t mask,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m4_m(mask,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei32_v_i32m8_m(vbool4_t mask,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m8_m(mask,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei32_v_i64m1_m(vbool64_t mask,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m1_m(mask,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei32_v_i64m2_m(vbool32_t mask,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m2_m(mask,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei32_v_i64m4_m(vbool16_t mask,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m4_m(mask,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei32_v_i64m8_m(vbool8_t mask,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m8_m(mask,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32_v_u8mf8_m(vbool64_t mask,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf8_m(mask,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32_v_u8mf4_m(vbool32_t mask,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf4_m(mask,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32_v_u8mf2_m(vbool16_t mask,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf2_m(mask,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei32_v_u8m1_m(vbool8_t mask,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m1_m(mask,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei32_v_u8m2_m(vbool4_t mask,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m2_m(mask,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32_v_u16mf4_m(vbool64_t mask,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf4_m(mask,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32_v_u16mf2_m(vbool32_t mask,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf2_m(mask,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei32_v_u16m1_m(vbool16_t mask,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m1_m(mask,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei32_v_u16m2_m(vbool8_t mask,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m2_m(mask,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei32_v_u16m4_m(vbool4_t mask,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m4_m(mask,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32_v_u32mf2_m(vbool64_t mask,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32mf2_m(mask,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei32_v_u32m1_m(vbool32_t mask,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m1_m(mask,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei32_v_u32m2_m(vbool16_t mask,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m2_m(mask,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei32_v_u32m4_m(vbool8_t mask,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m4_m(mask,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei32_v_u32m8_m(vbool4_t mask,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m8_m(mask,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei32_v_u64m1_m(vbool64_t mask,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m1_m(mask,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei32_v_u64m2_m(vbool32_t mask,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m2_m(mask,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei32_v_u64m4_m(vbool16_t mask,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m4_m(mask,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei32_v_u64m8_m(vbool8_t mask,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m8_m(mask,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32_v_f32mf2_m(vbool64_t mask,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32mf2_m(mask,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32_v_f32m1_m(vbool32_t mask,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m1_m(mask,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32_v_f32m2_m(vbool16_t mask,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m2_m(mask,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32_v_f32m4_m(vbool8_t mask,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m4_m(mask,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32_v_f32m8_m(vbool4_t mask,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m8_m(mask,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32_v_f64m1_m(vbool64_t mask,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m1_m(mask,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32_v_f64m2_m(vbool32_t mask,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m2_m(mask,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32_v_f64m4_m(vbool16_t mask,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m4_m(mask,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32_v_f64m8_m(vbool8_t mask,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m8_m(mask,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_mu-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_mu-1.c
new file mode 100644
index 0000000..8649055
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_mu-1.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei32_v_i8mf8_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei32_v_i8mf4_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei32_v_i8mf2_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei32_v_i8m1_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei32_v_i8m2_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei32_v_i16mf4_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei32_v_i16mf2_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei32_v_i16m1_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei32_v_i16m2_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei32_v_i16m4_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei32_v_i32mf2_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei32_v_i32m1_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei32_v_i32m2_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei32_v_i32m4_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei32_v_i32m8_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei32_v_i64m1_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei32_v_i64m2_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei32_v_i64m4_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei32_v_i64m8_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32_v_u8mf8_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32_v_u8mf4_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32_v_u8mf2_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei32_v_u8m1_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei32_v_u8m2_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32_v_u16mf4_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32_v_u16mf2_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei32_v_u16m1_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei32_v_u16m2_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei32_v_u16m4_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32_v_u32mf2_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei32_v_u32m1_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei32_v_u32m2_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei32_v_u32m4_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei32_v_u32m8_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei32_v_u64m1_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei32_v_u64m2_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei32_v_u64m4_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei32_v_u64m8_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32_v_f32mf2_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32_v_f32m1_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32_v_f32m2_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32_v_f32m4_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32_v_f32m8_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32_v_f64m1_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32_v_f64m2_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32_v_f64m4_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32_v_f64m8_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_mu-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_mu-2.c
new file mode 100644
index 0000000..9f9544c
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_mu-2.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei32_v_i8mf8_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei32_v_i8mf4_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei32_v_i8mf2_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei32_v_i8m1_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei32_v_i8m2_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei32_v_i16mf4_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei32_v_i16mf2_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei32_v_i16m1_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei32_v_i16m2_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei32_v_i16m4_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei32_v_i32mf2_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei32_v_i32m1_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei32_v_i32m2_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei32_v_i32m4_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei32_v_i32m8_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei32_v_i64m1_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei32_v_i64m2_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei32_v_i64m4_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei32_v_i64m8_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32_v_u8mf8_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32_v_u8mf4_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32_v_u8mf2_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei32_v_u8m1_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei32_v_u8m2_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32_v_u16mf4_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32_v_u16mf2_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei32_v_u16m1_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei32_v_u16m2_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei32_v_u16m4_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32_v_u32mf2_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei32_v_u32m1_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei32_v_u32m2_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei32_v_u32m4_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei32_v_u32m8_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei32_v_u64m1_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei32_v_u64m2_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei32_v_u64m4_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei32_v_u64m8_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32_v_f32mf2_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32_v_f32m1_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32_v_f32m2_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32_v_f32m4_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32_v_f32m8_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32_v_f64m1_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32_v_f64m2_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32_v_f64m4_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32_v_f64m8_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m8_mu(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_mu-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_mu-3.c
new file mode 100644
index 0000000..193afcf
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_mu-3.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei32_v_i8mf8_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei32_v_i8mf4_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei32_v_i8mf2_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei32_v_i8m1_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei32_v_i8m2_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei32_v_i16mf4_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei32_v_i16mf2_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei32_v_i16m1_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei32_v_i16m2_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei32_v_i16m4_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei32_v_i32mf2_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei32_v_i32m1_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei32_v_i32m2_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei32_v_i32m4_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei32_v_i32m8_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei32_v_i64m1_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei32_v_i64m2_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei32_v_i64m4_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei32_v_i64m8_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32_v_u8mf8_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32_v_u8mf4_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32_v_u8mf2_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei32_v_u8m1_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei32_v_u8m2_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32_v_u16mf4_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32_v_u16mf2_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei32_v_u16m1_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei32_v_u16m2_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei32_v_u16m4_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32_v_u32mf2_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei32_v_u32m1_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei32_v_u32m2_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei32_v_u32m4_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei32_v_u32m8_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei32_v_u64m1_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei32_v_u64m2_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei32_v_u64m4_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei32_v_u64m8_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32_v_f32mf2_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32_v_f32m1_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32_v_f32m2_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32_v_f32m4_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32_v_f32m8_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32_v_f64m1_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32_v_f64m2_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32_v_f64m4_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32_v_f64m8_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m8_mu(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_tu-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_tu-1.c
new file mode 100644
index 0000000..f754e65
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_tu-1.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei32_v_i8mf8_tu(vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf8_tu(merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei32_v_i8mf4_tu(vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf4_tu(merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei32_v_i8mf2_tu(vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf2_tu(merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei32_v_i8m1_tu(vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m1_tu(merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei32_v_i8m2_tu(vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m2_tu(merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei32_v_i16mf4_tu(vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf4_tu(merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei32_v_i16mf2_tu(vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf2_tu(merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei32_v_i16m1_tu(vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m1_tu(merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei32_v_i16m2_tu(vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m2_tu(merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei32_v_i16m4_tu(vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m4_tu(merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei32_v_i32mf2_tu(vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32mf2_tu(merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei32_v_i32m1_tu(vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m1_tu(merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei32_v_i32m2_tu(vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m2_tu(merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei32_v_i32m4_tu(vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m4_tu(merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei32_v_i32m8_tu(vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m8_tu(merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei32_v_i64m1_tu(vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m1_tu(merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei32_v_i64m2_tu(vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m2_tu(merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei32_v_i64m4_tu(vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m4_tu(merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei32_v_i64m8_tu(vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m8_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32_v_u8mf8_tu(vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf8_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32_v_u8mf4_tu(vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf4_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32_v_u8mf2_tu(vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf2_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei32_v_u8m1_tu(vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m1_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei32_v_u8m2_tu(vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m2_tu(merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32_v_u16mf4_tu(vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf4_tu(merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32_v_u16mf2_tu(vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf2_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei32_v_u16m1_tu(vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m1_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei32_v_u16m2_tu(vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m2_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei32_v_u16m4_tu(vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m4_tu(merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32_v_u32mf2_tu(vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32mf2_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei32_v_u32m1_tu(vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m1_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei32_v_u32m2_tu(vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m2_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei32_v_u32m4_tu(vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m4_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei32_v_u32m8_tu(vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m8_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei32_v_u64m1_tu(vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m1_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei32_v_u64m2_tu(vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m2_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei32_v_u64m4_tu(vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m4_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei32_v_u64m8_tu(vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m8_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32_v_f32mf2_tu(vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32mf2_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32_v_f32m1_tu(vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m1_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32_v_f32m2_tu(vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m2_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32_v_f32m4_tu(vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m4_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32_v_f32m8_tu(vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m8_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32_v_f64m1_tu(vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m1_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32_v_f64m2_tu(vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m2_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32_v_f64m4_tu(vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m4_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32_v_f64m8_tu(vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m8_tu(merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_tu-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_tu-2.c
new file mode 100644
index 0000000..e87d249
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_tu-2.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei32_v_i8mf8_tu(vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf8_tu(merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei32_v_i8mf4_tu(vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf4_tu(merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei32_v_i8mf2_tu(vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf2_tu(merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei32_v_i8m1_tu(vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m1_tu(merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei32_v_i8m2_tu(vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m2_tu(merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei32_v_i16mf4_tu(vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf4_tu(merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei32_v_i16mf2_tu(vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf2_tu(merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei32_v_i16m1_tu(vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m1_tu(merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei32_v_i16m2_tu(vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m2_tu(merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei32_v_i16m4_tu(vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m4_tu(merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei32_v_i32mf2_tu(vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32mf2_tu(merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei32_v_i32m1_tu(vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m1_tu(merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei32_v_i32m2_tu(vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m2_tu(merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei32_v_i32m4_tu(vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m4_tu(merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei32_v_i32m8_tu(vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m8_tu(merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei32_v_i64m1_tu(vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m1_tu(merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei32_v_i64m2_tu(vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m2_tu(merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei32_v_i64m4_tu(vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m4_tu(merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei32_v_i64m8_tu(vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m8_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32_v_u8mf8_tu(vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf8_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32_v_u8mf4_tu(vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf4_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32_v_u8mf2_tu(vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf2_tu(merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei32_v_u8m1_tu(vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m1_tu(merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei32_v_u8m2_tu(vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m2_tu(merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32_v_u16mf4_tu(vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf4_tu(merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32_v_u16mf2_tu(vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf2_tu(merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei32_v_u16m1_tu(vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m1_tu(merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei32_v_u16m2_tu(vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m2_tu(merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei32_v_u16m4_tu(vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m4_tu(merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32_v_u32mf2_tu(vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32mf2_tu(merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei32_v_u32m1_tu(vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m1_tu(merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei32_v_u32m2_tu(vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m2_tu(merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei32_v_u32m4_tu(vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m4_tu(merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei32_v_u32m8_tu(vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m8_tu(merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei32_v_u64m1_tu(vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m1_tu(merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei32_v_u64m2_tu(vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m2_tu(merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei32_v_u64m4_tu(vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m4_tu(merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei32_v_u64m8_tu(vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m8_tu(merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32_v_f32mf2_tu(vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32mf2_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32_v_f32m1_tu(vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m1_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32_v_f32m2_tu(vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m2_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32_v_f32m4_tu(vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m4_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32_v_f32m8_tu(vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m8_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32_v_f64m1_tu(vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m1_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32_v_f64m2_tu(vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m2_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32_v_f64m4_tu(vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m4_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32_v_f64m8_tu(vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m8_tu(merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_tu-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_tu-3.c
new file mode 100644
index 0000000..4f68a5f
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_tu-3.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei32_v_i8mf8_tu(vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf8_tu(merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei32_v_i8mf4_tu(vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf4_tu(merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei32_v_i8mf2_tu(vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf2_tu(merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei32_v_i8m1_tu(vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m1_tu(merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei32_v_i8m2_tu(vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m2_tu(merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei32_v_i16mf4_tu(vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf4_tu(merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei32_v_i16mf2_tu(vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf2_tu(merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei32_v_i16m1_tu(vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m1_tu(merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei32_v_i16m2_tu(vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m2_tu(merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei32_v_i16m4_tu(vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m4_tu(merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei32_v_i32mf2_tu(vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32mf2_tu(merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei32_v_i32m1_tu(vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m1_tu(merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei32_v_i32m2_tu(vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m2_tu(merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei32_v_i32m4_tu(vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m4_tu(merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei32_v_i32m8_tu(vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m8_tu(merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei32_v_i64m1_tu(vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m1_tu(merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei32_v_i64m2_tu(vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m2_tu(merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei32_v_i64m4_tu(vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m4_tu(merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei32_v_i64m8_tu(vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m8_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32_v_u8mf8_tu(vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf8_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32_v_u8mf4_tu(vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf4_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32_v_u8mf2_tu(vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf2_tu(merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei32_v_u8m1_tu(vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m1_tu(merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei32_v_u8m2_tu(vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m2_tu(merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32_v_u16mf4_tu(vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf4_tu(merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32_v_u16mf2_tu(vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf2_tu(merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei32_v_u16m1_tu(vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m1_tu(merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei32_v_u16m2_tu(vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m2_tu(merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei32_v_u16m4_tu(vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m4_tu(merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32_v_u32mf2_tu(vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32mf2_tu(merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei32_v_u32m1_tu(vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m1_tu(merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei32_v_u32m2_tu(vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m2_tu(merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei32_v_u32m4_tu(vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m4_tu(merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei32_v_u32m8_tu(vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m8_tu(merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei32_v_u64m1_tu(vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m1_tu(merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei32_v_u64m2_tu(vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m2_tu(merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei32_v_u64m4_tu(vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m4_tu(merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei32_v_u64m8_tu(vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m8_tu(merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32_v_f32mf2_tu(vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32mf2_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32_v_f32m1_tu(vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m1_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32_v_f32m2_tu(vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m2_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32_v_f32m4_tu(vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m4_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32_v_f32m8_tu(vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m8_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32_v_f64m1_tu(vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m1_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32_v_f64m2_tu(vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m2_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32_v_f64m4_tu(vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m4_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32_v_f64m8_tu(vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m8_tu(merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_tum-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_tum-1.c
new file mode 100644
index 0000000..22dee05
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_tum-1.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei32_v_i8mf8_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei32_v_i8mf4_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei32_v_i8mf2_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei32_v_i8m1_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei32_v_i8m2_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei32_v_i16mf4_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei32_v_i16mf2_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei32_v_i16m1_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei32_v_i16m2_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei32_v_i16m4_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei32_v_i32mf2_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei32_v_i32m1_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei32_v_i32m2_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei32_v_i32m4_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei32_v_i32m8_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei32_v_i64m1_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei32_v_i64m2_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei32_v_i64m4_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei32_v_i64m8_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32_v_u8mf8_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32_v_u8mf4_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32_v_u8mf2_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei32_v_u8m1_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei32_v_u8m2_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32_v_u16mf4_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32_v_u16mf2_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei32_v_u16m1_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei32_v_u16m2_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei32_v_u16m4_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32_v_u32mf2_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei32_v_u32m1_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei32_v_u32m2_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei32_v_u32m4_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei32_v_u32m8_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei32_v_u64m1_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei32_v_u64m2_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei32_v_u64m4_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei32_v_u64m8_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32_v_f32mf2_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32_v_f32m1_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32_v_f32m2_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32_v_f32m4_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32_v_f32m8_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32_v_f64m1_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32_v_f64m2_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32_v_f64m4_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32_v_f64m8_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_tum-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_tum-2.c
new file mode 100644
index 0000000..d408ab7
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_tum-2.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei32_v_i8mf8_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei32_v_i8mf4_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei32_v_i8mf2_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei32_v_i8m1_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei32_v_i8m2_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei32_v_i16mf4_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei32_v_i16mf2_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei32_v_i16m1_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei32_v_i16m2_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei32_v_i16m4_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei32_v_i32mf2_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei32_v_i32m1_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei32_v_i32m2_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei32_v_i32m4_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei32_v_i32m8_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei32_v_i64m1_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei32_v_i64m2_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei32_v_i64m4_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei32_v_i64m8_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32_v_u8mf8_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32_v_u8mf4_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32_v_u8mf2_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei32_v_u8m1_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei32_v_u8m2_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32_v_u16mf4_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32_v_u16mf2_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei32_v_u16m1_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei32_v_u16m2_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei32_v_u16m4_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32_v_u32mf2_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei32_v_u32m1_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei32_v_u32m2_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei32_v_u32m4_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei32_v_u32m8_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei32_v_u64m1_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei32_v_u64m2_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei32_v_u64m4_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei32_v_u64m8_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32_v_f32mf2_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32_v_f32m1_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32_v_f32m2_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32_v_f32m4_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32_v_f32m8_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32_v_f64m1_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32_v_f64m2_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32_v_f64m4_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32_v_f64m8_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m8_tum(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_tum-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_tum-3.c
new file mode 100644
index 0000000..c3732b9
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_tum-3.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei32_v_i8mf8_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei32_v_i8mf4_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei32_v_i8mf2_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei32_v_i8m1_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei32_v_i8m2_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei32_v_i16mf4_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei32_v_i16mf2_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei32_v_i16m1_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei32_v_i16m2_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei32_v_i16m4_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei32_v_i32mf2_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei32_v_i32m1_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei32_v_i32m2_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei32_v_i32m4_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei32_v_i32m8_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei32_v_i64m1_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei32_v_i64m2_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei32_v_i64m4_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei32_v_i64m8_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32_v_u8mf8_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32_v_u8mf4_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32_v_u8mf2_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei32_v_u8m1_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei32_v_u8m2_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32_v_u16mf4_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32_v_u16mf2_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei32_v_u16m1_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei32_v_u16m2_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei32_v_u16m4_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32_v_u32mf2_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei32_v_u32m1_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei32_v_u32m2_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei32_v_u32m4_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei32_v_u32m8_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei32_v_u64m1_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei32_v_u64m2_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei32_v_u64m4_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei32_v_u64m8_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32_v_f32mf2_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32_v_f32m1_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32_v_f32m2_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32_v_f32m4_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32_v_f32m8_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32_v_f64m1_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32_v_f64m2_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32_v_f64m4_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32_v_f64m8_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m8_tum(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_tumu-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_tumu-1.c
new file mode 100644
index 0000000..7cd8c40
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_tumu-1.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei32_v_i8mf8_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei32_v_i8mf4_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei32_v_i8mf2_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei32_v_i8m1_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei32_v_i8m2_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei32_v_i16mf4_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei32_v_i16mf2_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei32_v_i16m1_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei32_v_i16m2_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei32_v_i16m4_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei32_v_i32mf2_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei32_v_i32m1_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei32_v_i32m2_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei32_v_i32m4_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei32_v_i32m8_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei32_v_i64m1_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei32_v_i64m2_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei32_v_i64m4_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei32_v_i64m8_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32_v_u8mf8_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32_v_u8mf4_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32_v_u8mf2_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei32_v_u8m1_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei32_v_u8m2_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32_v_u16mf4_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32_v_u16mf2_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei32_v_u16m1_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei32_v_u16m2_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei32_v_u16m4_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32_v_u32mf2_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei32_v_u32m1_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei32_v_u32m2_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei32_v_u32m4_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei32_v_u32m8_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei32_v_u64m1_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei32_v_u64m2_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei32_v_u64m4_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei32_v_u64m8_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32_v_f32mf2_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32_v_f32m1_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32_v_f32m2_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32_v_f32m4_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32_v_f32m8_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32_v_f64m1_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32_v_f64m2_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32_v_f64m4_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32_v_f64m8_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_tumu-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_tumu-2.c
new file mode 100644
index 0000000..cdd8374
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_tumu-2.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei32_v_i8mf8_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei32_v_i8mf4_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei32_v_i8mf2_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei32_v_i8m1_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei32_v_i8m2_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei32_v_i16mf4_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei32_v_i16mf2_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei32_v_i16m1_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei32_v_i16m2_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei32_v_i16m4_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei32_v_i32mf2_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei32_v_i32m1_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei32_v_i32m2_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei32_v_i32m4_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei32_v_i32m8_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei32_v_i64m1_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei32_v_i64m2_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei32_v_i64m4_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei32_v_i64m8_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32_v_u8mf8_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32_v_u8mf4_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32_v_u8mf2_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei32_v_u8m1_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei32_v_u8m2_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32_v_u16mf4_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32_v_u16mf2_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei32_v_u16m1_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei32_v_u16m2_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei32_v_u16m4_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32_v_u32mf2_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei32_v_u32m1_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei32_v_u32m2_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei32_v_u32m4_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei32_v_u32m8_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei32_v_u64m1_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei32_v_u64m2_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei32_v_u64m4_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei32_v_u64m8_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32_v_f32mf2_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32_v_f32m1_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32_v_f32m2_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32_v_f32m4_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32_v_f32m8_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32_v_f64m1_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32_v_f64m2_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32_v_f64m4_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32_v_f64m8_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_tumu-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_tumu-3.c
new file mode 100644
index 0000000..731ae4c
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei32_v_tumu-3.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei32_v_i8mf8_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei32_v_i8mf4_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei32_v_i8mf2_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei32_v_i8m1_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei32_v_i8m2_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i8m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei32_v_i16mf4_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei32_v_i16mf2_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei32_v_i16m1_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei32_v_i16m2_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei32_v_i16m4_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i16m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei32_v_i32mf2_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei32_v_i32m1_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei32_v_i32m2_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei32_v_i32m4_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei32_v_i32m8_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i32m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei32_v_i64m1_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei32_v_i64m2_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei32_v_i64m4_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei32_v_i64m8_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_i64m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei32_v_u8mf8_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei32_v_u8mf4_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei32_v_u8mf2_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei32_v_u8m1_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei32_v_u8m2_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u8m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei32_v_u16mf4_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei32_v_u16mf2_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei32_v_u16m1_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei32_v_u16m2_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei32_v_u16m4_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u16m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei32_v_u32mf2_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei32_v_u32m1_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei32_v_u32m2_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei32_v_u32m4_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei32_v_u32m8_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u32m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei32_v_u64m1_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei32_v_u64m2_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei32_v_u64m4_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei32_v_u64m8_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_u64m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei32_v_f32mf2_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei32_v_f32m1_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei32_v_f32m2_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei32_v_f32m4_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei32_v_f32m8_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint32m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f32m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei32_v_f64m1_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint32mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei32_v_f64m2_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint32m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei32_v_f64m4_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint32m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei32_v_f64m8_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint32m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei32_v_f64m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vluxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v-1.c
new file mode 100644
index 0000000..9bfdf78
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v-1.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei64_v_i8mf8(const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf8(base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei64_v_i8mf4(const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf4(base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei64_v_i8mf2(const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf2(base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei64_v_i8m1(const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8m1(base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei64_v_i16mf4(const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf4(base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei64_v_i16mf2(const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf2(base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei64_v_i16m1(const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m1(base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei64_v_i16m2(const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m2(base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei64_v_i32mf2(const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32mf2(base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei64_v_i32m1(const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m1(base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei64_v_i32m2(const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m2(base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei64_v_i32m4(const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m4(base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei64_v_i64m1(const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m1(base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei64_v_i64m2(const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m2(base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei64_v_i64m4(const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m4(base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei64_v_i64m8(const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m8(base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64_v_u8mf8(const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf8(base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64_v_u8mf4(const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf4(base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64_v_u8mf2(const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf2(base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei64_v_u8m1(const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8m1(base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64_v_u16mf4(const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf4(base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64_v_u16mf2(const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf2(base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei64_v_u16m1(const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m1(base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei64_v_u16m2(const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m2(base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64_v_u32mf2(const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32mf2(base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei64_v_u32m1(const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m1(base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei64_v_u32m2(const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m2(base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei64_v_u32m4(const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m4(base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei64_v_u64m1(const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m1(base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei64_v_u64m2(const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m2(base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei64_v_u64m4(const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m4(base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei64_v_u64m8(const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m8(base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64_v_f32mf2(const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32mf2(base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64_v_f32m1(const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m1(base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64_v_f32m2(const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m2(base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64_v_f32m4(const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m4(base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64_v_f64m1(const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m1(base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64_v_f64m2(const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m2(base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64_v_f64m4(const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m4(base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64_v_f64m8(const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m8(base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v-2.c
new file mode 100644
index 0000000..592c216
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v-2.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei64_v_i8mf8(const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf8(base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei64_v_i8mf4(const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf4(base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei64_v_i8mf2(const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf2(base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei64_v_i8m1(const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8m1(base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei64_v_i16mf4(const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf4(base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei64_v_i16mf2(const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf2(base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei64_v_i16m1(const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m1(base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei64_v_i16m2(const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m2(base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei64_v_i32mf2(const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32mf2(base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei64_v_i32m1(const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m1(base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei64_v_i32m2(const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m2(base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei64_v_i32m4(const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m4(base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei64_v_i64m1(const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m1(base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei64_v_i64m2(const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m2(base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei64_v_i64m4(const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m4(base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei64_v_i64m8(const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m8(base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64_v_u8mf8(const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf8(base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64_v_u8mf4(const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf4(base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64_v_u8mf2(const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf2(base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei64_v_u8m1(const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8m1(base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64_v_u16mf4(const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf4(base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64_v_u16mf2(const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf2(base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei64_v_u16m1(const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m1(base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei64_v_u16m2(const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m2(base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64_v_u32mf2(const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32mf2(base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei64_v_u32m1(const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m1(base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei64_v_u32m2(const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m2(base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei64_v_u32m4(const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m4(base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei64_v_u64m1(const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m1(base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei64_v_u64m2(const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m2(base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei64_v_u64m4(const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m4(base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei64_v_u64m8(const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m8(base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64_v_f32mf2(const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32mf2(base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64_v_f32m1(const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m1(base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64_v_f32m2(const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m2(base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64_v_f32m4(const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m4(base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64_v_f64m1(const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m1(base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64_v_f64m2(const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m2(base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64_v_f64m4(const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m4(base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64_v_f64m8(const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m8(base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v-3.c
new file mode 100644
index 0000000..8618920
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v-3.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei64_v_i8mf8(const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf8(base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei64_v_i8mf4(const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf4(base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei64_v_i8mf2(const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf2(base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei64_v_i8m1(const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8m1(base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei64_v_i16mf4(const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf4(base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei64_v_i16mf2(const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf2(base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei64_v_i16m1(const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m1(base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei64_v_i16m2(const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m2(base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei64_v_i32mf2(const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32mf2(base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei64_v_i32m1(const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m1(base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei64_v_i32m2(const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m2(base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei64_v_i32m4(const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m4(base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei64_v_i64m1(const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m1(base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei64_v_i64m2(const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m2(base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei64_v_i64m4(const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m4(base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei64_v_i64m8(const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m8(base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64_v_u8mf8(const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf8(base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64_v_u8mf4(const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf4(base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64_v_u8mf2(const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf2(base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei64_v_u8m1(const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8m1(base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64_v_u16mf4(const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf4(base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64_v_u16mf2(const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf2(base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei64_v_u16m1(const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m1(base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei64_v_u16m2(const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m2(base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64_v_u32mf2(const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32mf2(base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei64_v_u32m1(const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m1(base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei64_v_u32m2(const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m2(base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei64_v_u32m4(const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m4(base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei64_v_u64m1(const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m1(base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei64_v_u64m2(const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m2(base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei64_v_u64m4(const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m4(base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei64_v_u64m8(const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m8(base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64_v_f32mf2(const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32mf2(base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64_v_f32m1(const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m1(base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64_v_f32m2(const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m2(base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64_v_f32m4(const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m4(base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64_v_f64m1(const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m1(base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64_v_f64m2(const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m2(base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64_v_f64m4(const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m4(base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64_v_f64m8(const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m8(base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_m-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_m-1.c
new file mode 100644
index 0000000..05518c9
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_m-1.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei64_v_i8mf8_m(vbool64_t mask,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf8_m(mask,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei64_v_i8mf4_m(vbool32_t mask,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf4_m(mask,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei64_v_i8mf2_m(vbool16_t mask,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf2_m(mask,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei64_v_i8m1_m(vbool8_t mask,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8m1_m(mask,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei64_v_i16mf4_m(vbool64_t mask,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf4_m(mask,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei64_v_i16mf2_m(vbool32_t mask,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf2_m(mask,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei64_v_i16m1_m(vbool16_t mask,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m1_m(mask,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei64_v_i16m2_m(vbool8_t mask,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m2_m(mask,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei64_v_i32mf2_m(vbool64_t mask,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32mf2_m(mask,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei64_v_i32m1_m(vbool32_t mask,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m1_m(mask,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei64_v_i32m2_m(vbool16_t mask,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m2_m(mask,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei64_v_i32m4_m(vbool8_t mask,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m4_m(mask,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei64_v_i64m1_m(vbool64_t mask,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m1_m(mask,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei64_v_i64m2_m(vbool32_t mask,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m2_m(mask,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei64_v_i64m4_m(vbool16_t mask,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m4_m(mask,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei64_v_i64m8_m(vbool8_t mask,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m8_m(mask,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64_v_u8mf8_m(vbool64_t mask,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf8_m(mask,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64_v_u8mf4_m(vbool32_t mask,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf4_m(mask,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64_v_u8mf2_m(vbool16_t mask,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf2_m(mask,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei64_v_u8m1_m(vbool8_t mask,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8m1_m(mask,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64_v_u16mf4_m(vbool64_t mask,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf4_m(mask,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64_v_u16mf2_m(vbool32_t mask,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf2_m(mask,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei64_v_u16m1_m(vbool16_t mask,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m1_m(mask,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei64_v_u16m2_m(vbool8_t mask,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m2_m(mask,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64_v_u32mf2_m(vbool64_t mask,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32mf2_m(mask,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei64_v_u32m1_m(vbool32_t mask,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m1_m(mask,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei64_v_u32m2_m(vbool16_t mask,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m2_m(mask,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei64_v_u32m4_m(vbool8_t mask,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m4_m(mask,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei64_v_u64m1_m(vbool64_t mask,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m1_m(mask,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei64_v_u64m2_m(vbool32_t mask,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m2_m(mask,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei64_v_u64m4_m(vbool16_t mask,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m4_m(mask,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei64_v_u64m8_m(vbool8_t mask,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m8_m(mask,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64_v_f32mf2_m(vbool64_t mask,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32mf2_m(mask,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64_v_f32m1_m(vbool32_t mask,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m1_m(mask,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64_v_f32m2_m(vbool16_t mask,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m2_m(mask,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64_v_f32m4_m(vbool8_t mask,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m4_m(mask,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64_v_f64m1_m(vbool64_t mask,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m1_m(mask,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64_v_f64m2_m(vbool32_t mask,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m2_m(mask,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64_v_f64m4_m(vbool16_t mask,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m4_m(mask,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64_v_f64m8_m(vbool8_t mask,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m8_m(mask,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_m-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_m-2.c
new file mode 100644
index 0000000..37375e4
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_m-2.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei64_v_i8mf8_m(vbool64_t mask,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf8_m(mask,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei64_v_i8mf4_m(vbool32_t mask,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf4_m(mask,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei64_v_i8mf2_m(vbool16_t mask,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf2_m(mask,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei64_v_i8m1_m(vbool8_t mask,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8m1_m(mask,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei64_v_i16mf4_m(vbool64_t mask,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf4_m(mask,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei64_v_i16mf2_m(vbool32_t mask,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf2_m(mask,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei64_v_i16m1_m(vbool16_t mask,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m1_m(mask,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei64_v_i16m2_m(vbool8_t mask,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m2_m(mask,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei64_v_i32mf2_m(vbool64_t mask,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32mf2_m(mask,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei64_v_i32m1_m(vbool32_t mask,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m1_m(mask,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei64_v_i32m2_m(vbool16_t mask,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m2_m(mask,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei64_v_i32m4_m(vbool8_t mask,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m4_m(mask,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei64_v_i64m1_m(vbool64_t mask,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m1_m(mask,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei64_v_i64m2_m(vbool32_t mask,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m2_m(mask,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei64_v_i64m4_m(vbool16_t mask,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m4_m(mask,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei64_v_i64m8_m(vbool8_t mask,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m8_m(mask,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64_v_u8mf8_m(vbool64_t mask,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf8_m(mask,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64_v_u8mf4_m(vbool32_t mask,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf4_m(mask,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64_v_u8mf2_m(vbool16_t mask,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf2_m(mask,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei64_v_u8m1_m(vbool8_t mask,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8m1_m(mask,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64_v_u16mf4_m(vbool64_t mask,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf4_m(mask,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64_v_u16mf2_m(vbool32_t mask,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf2_m(mask,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei64_v_u16m1_m(vbool16_t mask,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m1_m(mask,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei64_v_u16m2_m(vbool8_t mask,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m2_m(mask,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64_v_u32mf2_m(vbool64_t mask,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32mf2_m(mask,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei64_v_u32m1_m(vbool32_t mask,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m1_m(mask,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei64_v_u32m2_m(vbool16_t mask,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m2_m(mask,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei64_v_u32m4_m(vbool8_t mask,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m4_m(mask,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei64_v_u64m1_m(vbool64_t mask,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m1_m(mask,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei64_v_u64m2_m(vbool32_t mask,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m2_m(mask,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei64_v_u64m4_m(vbool16_t mask,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m4_m(mask,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei64_v_u64m8_m(vbool8_t mask,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m8_m(mask,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64_v_f32mf2_m(vbool64_t mask,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32mf2_m(mask,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64_v_f32m1_m(vbool32_t mask,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m1_m(mask,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64_v_f32m2_m(vbool16_t mask,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m2_m(mask,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64_v_f32m4_m(vbool8_t mask,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m4_m(mask,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64_v_f64m1_m(vbool64_t mask,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m1_m(mask,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64_v_f64m2_m(vbool32_t mask,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m2_m(mask,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64_v_f64m4_m(vbool16_t mask,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m4_m(mask,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64_v_f64m8_m(vbool8_t mask,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m8_m(mask,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_m-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_m-3.c
new file mode 100644
index 0000000..765d2da
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_m-3.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei64_v_i8mf8_m(vbool64_t mask,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf8_m(mask,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei64_v_i8mf4_m(vbool32_t mask,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf4_m(mask,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei64_v_i8mf2_m(vbool16_t mask,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf2_m(mask,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei64_v_i8m1_m(vbool8_t mask,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8m1_m(mask,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei64_v_i16mf4_m(vbool64_t mask,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf4_m(mask,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei64_v_i16mf2_m(vbool32_t mask,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf2_m(mask,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei64_v_i16m1_m(vbool16_t mask,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m1_m(mask,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei64_v_i16m2_m(vbool8_t mask,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m2_m(mask,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei64_v_i32mf2_m(vbool64_t mask,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32mf2_m(mask,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei64_v_i32m1_m(vbool32_t mask,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m1_m(mask,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei64_v_i32m2_m(vbool16_t mask,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m2_m(mask,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei64_v_i32m4_m(vbool8_t mask,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m4_m(mask,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei64_v_i64m1_m(vbool64_t mask,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m1_m(mask,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei64_v_i64m2_m(vbool32_t mask,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m2_m(mask,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei64_v_i64m4_m(vbool16_t mask,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m4_m(mask,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei64_v_i64m8_m(vbool8_t mask,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m8_m(mask,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64_v_u8mf8_m(vbool64_t mask,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf8_m(mask,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64_v_u8mf4_m(vbool32_t mask,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf4_m(mask,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64_v_u8mf2_m(vbool16_t mask,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf2_m(mask,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei64_v_u8m1_m(vbool8_t mask,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8m1_m(mask,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64_v_u16mf4_m(vbool64_t mask,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf4_m(mask,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64_v_u16mf2_m(vbool32_t mask,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf2_m(mask,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei64_v_u16m1_m(vbool16_t mask,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m1_m(mask,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei64_v_u16m2_m(vbool8_t mask,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m2_m(mask,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64_v_u32mf2_m(vbool64_t mask,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32mf2_m(mask,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei64_v_u32m1_m(vbool32_t mask,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m1_m(mask,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei64_v_u32m2_m(vbool16_t mask,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m2_m(mask,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei64_v_u32m4_m(vbool8_t mask,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m4_m(mask,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei64_v_u64m1_m(vbool64_t mask,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m1_m(mask,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei64_v_u64m2_m(vbool32_t mask,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m2_m(mask,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei64_v_u64m4_m(vbool16_t mask,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m4_m(mask,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei64_v_u64m8_m(vbool8_t mask,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m8_m(mask,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64_v_f32mf2_m(vbool64_t mask,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32mf2_m(mask,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64_v_f32m1_m(vbool32_t mask,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m1_m(mask,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64_v_f32m2_m(vbool16_t mask,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m2_m(mask,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64_v_f32m4_m(vbool8_t mask,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m4_m(mask,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64_v_f64m1_m(vbool64_t mask,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m1_m(mask,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64_v_f64m2_m(vbool32_t mask,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m2_m(mask,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64_v_f64m4_m(vbool16_t mask,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m4_m(mask,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64_v_f64m8_m(vbool8_t mask,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m8_m(mask,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_mu-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_mu-1.c
new file mode 100644
index 0000000..12fa84d
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_mu-1.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei64_v_i8mf8_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei64_v_i8mf4_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei64_v_i8mf2_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei64_v_i8m1_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei64_v_i16mf4_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei64_v_i16mf2_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei64_v_i16m1_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei64_v_i16m2_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei64_v_i32mf2_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei64_v_i32m1_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei64_v_i32m2_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei64_v_i32m4_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei64_v_i64m1_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei64_v_i64m2_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei64_v_i64m4_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei64_v_i64m8_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64_v_u8mf8_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64_v_u8mf4_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64_v_u8mf2_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei64_v_u8m1_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64_v_u16mf4_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64_v_u16mf2_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei64_v_u16m1_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei64_v_u16m2_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64_v_u32mf2_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei64_v_u32m1_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei64_v_u32m2_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei64_v_u32m4_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei64_v_u64m1_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei64_v_u64m2_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei64_v_u64m4_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei64_v_u64m8_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64_v_f32mf2_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64_v_f32m1_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64_v_f32m2_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64_v_f32m4_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64_v_f64m1_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64_v_f64m2_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64_v_f64m4_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64_v_f64m8_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_mu-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_mu-2.c
new file mode 100644
index 0000000..7f00b51
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_mu-2.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei64_v_i8mf8_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei64_v_i8mf4_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei64_v_i8mf2_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei64_v_i8m1_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei64_v_i16mf4_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei64_v_i16mf2_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei64_v_i16m1_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei64_v_i16m2_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei64_v_i32mf2_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei64_v_i32m1_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei64_v_i32m2_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei64_v_i32m4_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei64_v_i64m1_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei64_v_i64m2_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei64_v_i64m4_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei64_v_i64m8_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64_v_u8mf8_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64_v_u8mf4_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64_v_u8mf2_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei64_v_u8m1_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64_v_u16mf4_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64_v_u16mf2_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei64_v_u16m1_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei64_v_u16m2_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64_v_u32mf2_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei64_v_u32m1_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei64_v_u32m2_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei64_v_u32m4_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei64_v_u64m1_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei64_v_u64m2_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei64_v_u64m4_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei64_v_u64m8_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64_v_f32mf2_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64_v_f32m1_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64_v_f32m2_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64_v_f32m4_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64_v_f64m1_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64_v_f64m2_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64_v_f64m4_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64_v_f64m8_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m8_mu(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_mu-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_mu-3.c
new file mode 100644
index 0000000..c89e445
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_mu-3.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei64_v_i8mf8_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei64_v_i8mf4_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei64_v_i8mf2_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei64_v_i8m1_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei64_v_i16mf4_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei64_v_i16mf2_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei64_v_i16m1_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei64_v_i16m2_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei64_v_i32mf2_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei64_v_i32m1_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei64_v_i32m2_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei64_v_i32m4_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei64_v_i64m1_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei64_v_i64m2_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei64_v_i64m4_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei64_v_i64m8_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64_v_u8mf8_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64_v_u8mf4_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64_v_u8mf2_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei64_v_u8m1_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64_v_u16mf4_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64_v_u16mf2_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei64_v_u16m1_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei64_v_u16m2_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64_v_u32mf2_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei64_v_u32m1_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei64_v_u32m2_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei64_v_u32m4_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei64_v_u64m1_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei64_v_u64m2_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei64_v_u64m4_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei64_v_u64m8_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64_v_f32mf2_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64_v_f32m1_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64_v_f32m2_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64_v_f32m4_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64_v_f64m1_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64_v_f64m2_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64_v_f64m4_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64_v_f64m8_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m8_mu(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_tu-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_tu-1.c
new file mode 100644
index 0000000..8d612b3
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_tu-1.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei64_v_i8mf8_tu(vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf8_tu(merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei64_v_i8mf4_tu(vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf4_tu(merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei64_v_i8mf2_tu(vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf2_tu(merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei64_v_i8m1_tu(vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8m1_tu(merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei64_v_i16mf4_tu(vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf4_tu(merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei64_v_i16mf2_tu(vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf2_tu(merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei64_v_i16m1_tu(vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m1_tu(merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei64_v_i16m2_tu(vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m2_tu(merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei64_v_i32mf2_tu(vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32mf2_tu(merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei64_v_i32m1_tu(vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m1_tu(merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei64_v_i32m2_tu(vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m2_tu(merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei64_v_i32m4_tu(vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m4_tu(merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei64_v_i64m1_tu(vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m1_tu(merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei64_v_i64m2_tu(vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m2_tu(merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei64_v_i64m4_tu(vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m4_tu(merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei64_v_i64m8_tu(vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m8_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64_v_u8mf8_tu(vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf8_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64_v_u8mf4_tu(vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf4_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64_v_u8mf2_tu(vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf2_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei64_v_u8m1_tu(vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8m1_tu(merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64_v_u16mf4_tu(vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf4_tu(merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64_v_u16mf2_tu(vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf2_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei64_v_u16m1_tu(vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m1_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei64_v_u16m2_tu(vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m2_tu(merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64_v_u32mf2_tu(vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32mf2_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei64_v_u32m1_tu(vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m1_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei64_v_u32m2_tu(vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m2_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei64_v_u32m4_tu(vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m4_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei64_v_u64m1_tu(vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m1_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei64_v_u64m2_tu(vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m2_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei64_v_u64m4_tu(vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m4_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei64_v_u64m8_tu(vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m8_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64_v_f32mf2_tu(vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32mf2_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64_v_f32m1_tu(vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m1_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64_v_f32m2_tu(vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m2_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64_v_f32m4_tu(vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m4_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64_v_f64m1_tu(vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m1_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64_v_f64m2_tu(vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m2_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64_v_f64m4_tu(vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m4_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64_v_f64m8_tu(vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m8_tu(merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_tu-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_tu-2.c
new file mode 100644
index 0000000..f99769f
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_tu-2.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei64_v_i8mf8_tu(vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf8_tu(merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei64_v_i8mf4_tu(vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf4_tu(merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei64_v_i8mf2_tu(vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf2_tu(merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei64_v_i8m1_tu(vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8m1_tu(merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei64_v_i16mf4_tu(vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf4_tu(merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei64_v_i16mf2_tu(vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf2_tu(merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei64_v_i16m1_tu(vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m1_tu(merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei64_v_i16m2_tu(vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m2_tu(merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei64_v_i32mf2_tu(vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32mf2_tu(merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei64_v_i32m1_tu(vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m1_tu(merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei64_v_i32m2_tu(vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m2_tu(merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei64_v_i32m4_tu(vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m4_tu(merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei64_v_i64m1_tu(vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m1_tu(merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei64_v_i64m2_tu(vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m2_tu(merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei64_v_i64m4_tu(vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m4_tu(merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei64_v_i64m8_tu(vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m8_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64_v_u8mf8_tu(vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf8_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64_v_u8mf4_tu(vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf4_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64_v_u8mf2_tu(vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf2_tu(merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei64_v_u8m1_tu(vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8m1_tu(merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64_v_u16mf4_tu(vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf4_tu(merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64_v_u16mf2_tu(vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf2_tu(merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei64_v_u16m1_tu(vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m1_tu(merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei64_v_u16m2_tu(vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m2_tu(merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64_v_u32mf2_tu(vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32mf2_tu(merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei64_v_u32m1_tu(vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m1_tu(merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei64_v_u32m2_tu(vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m2_tu(merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei64_v_u32m4_tu(vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m4_tu(merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei64_v_u64m1_tu(vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m1_tu(merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei64_v_u64m2_tu(vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m2_tu(merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei64_v_u64m4_tu(vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m4_tu(merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei64_v_u64m8_tu(vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m8_tu(merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64_v_f32mf2_tu(vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32mf2_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64_v_f32m1_tu(vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m1_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64_v_f32m2_tu(vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m2_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64_v_f32m4_tu(vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m4_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64_v_f64m1_tu(vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m1_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64_v_f64m2_tu(vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m2_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64_v_f64m4_tu(vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m4_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64_v_f64m8_tu(vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m8_tu(merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_tu-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_tu-3.c
new file mode 100644
index 0000000..71ab181
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_tu-3.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei64_v_i8mf8_tu(vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf8_tu(merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei64_v_i8mf4_tu(vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf4_tu(merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei64_v_i8mf2_tu(vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf2_tu(merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei64_v_i8m1_tu(vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8m1_tu(merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei64_v_i16mf4_tu(vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf4_tu(merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei64_v_i16mf2_tu(vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf2_tu(merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei64_v_i16m1_tu(vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m1_tu(merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei64_v_i16m2_tu(vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m2_tu(merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei64_v_i32mf2_tu(vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32mf2_tu(merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei64_v_i32m1_tu(vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m1_tu(merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei64_v_i32m2_tu(vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m2_tu(merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei64_v_i32m4_tu(vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m4_tu(merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei64_v_i64m1_tu(vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m1_tu(merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei64_v_i64m2_tu(vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m2_tu(merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei64_v_i64m4_tu(vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m4_tu(merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei64_v_i64m8_tu(vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m8_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64_v_u8mf8_tu(vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf8_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64_v_u8mf4_tu(vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf4_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64_v_u8mf2_tu(vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf2_tu(merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei64_v_u8m1_tu(vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8m1_tu(merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64_v_u16mf4_tu(vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf4_tu(merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64_v_u16mf2_tu(vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf2_tu(merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei64_v_u16m1_tu(vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m1_tu(merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei64_v_u16m2_tu(vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m2_tu(merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64_v_u32mf2_tu(vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32mf2_tu(merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei64_v_u32m1_tu(vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m1_tu(merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei64_v_u32m2_tu(vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m2_tu(merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei64_v_u32m4_tu(vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m4_tu(merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei64_v_u64m1_tu(vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m1_tu(merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei64_v_u64m2_tu(vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m2_tu(merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei64_v_u64m4_tu(vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m4_tu(merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei64_v_u64m8_tu(vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m8_tu(merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64_v_f32mf2_tu(vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32mf2_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64_v_f32m1_tu(vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m1_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64_v_f32m2_tu(vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m2_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64_v_f32m4_tu(vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m4_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64_v_f64m1_tu(vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m1_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64_v_f64m2_tu(vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m2_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64_v_f64m4_tu(vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m4_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64_v_f64m8_tu(vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m8_tu(merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_tum-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_tum-1.c
new file mode 100644
index 0000000..f57d5f3
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_tum-1.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei64_v_i8mf8_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei64_v_i8mf4_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei64_v_i8mf2_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei64_v_i8m1_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei64_v_i16mf4_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei64_v_i16mf2_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei64_v_i16m1_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei64_v_i16m2_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei64_v_i32mf2_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei64_v_i32m1_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei64_v_i32m2_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei64_v_i32m4_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei64_v_i64m1_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei64_v_i64m2_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei64_v_i64m4_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei64_v_i64m8_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64_v_u8mf8_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64_v_u8mf4_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64_v_u8mf2_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei64_v_u8m1_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64_v_u16mf4_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64_v_u16mf2_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei64_v_u16m1_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei64_v_u16m2_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64_v_u32mf2_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei64_v_u32m1_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei64_v_u32m2_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei64_v_u32m4_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei64_v_u64m1_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei64_v_u64m2_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei64_v_u64m4_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei64_v_u64m8_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64_v_f32mf2_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64_v_f32m1_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64_v_f32m2_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64_v_f32m4_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64_v_f64m1_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64_v_f64m2_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64_v_f64m4_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64_v_f64m8_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_tum-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_tum-2.c
new file mode 100644
index 0000000..a69943d
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_tum-2.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei64_v_i8mf8_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei64_v_i8mf4_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei64_v_i8mf2_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei64_v_i8m1_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei64_v_i16mf4_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei64_v_i16mf2_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei64_v_i16m1_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei64_v_i16m2_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei64_v_i32mf2_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei64_v_i32m1_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei64_v_i32m2_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei64_v_i32m4_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei64_v_i64m1_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei64_v_i64m2_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei64_v_i64m4_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei64_v_i64m8_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64_v_u8mf8_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64_v_u8mf4_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64_v_u8mf2_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei64_v_u8m1_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64_v_u16mf4_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64_v_u16mf2_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei64_v_u16m1_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei64_v_u16m2_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64_v_u32mf2_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei64_v_u32m1_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei64_v_u32m2_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei64_v_u32m4_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei64_v_u64m1_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei64_v_u64m2_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei64_v_u64m4_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei64_v_u64m8_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64_v_f32mf2_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64_v_f32m1_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64_v_f32m2_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64_v_f32m4_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64_v_f64m1_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64_v_f64m2_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64_v_f64m4_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64_v_f64m8_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m8_tum(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_tum-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_tum-3.c
new file mode 100644
index 0000000..f58b39b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_tum-3.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei64_v_i8mf8_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei64_v_i8mf4_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei64_v_i8mf2_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei64_v_i8m1_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei64_v_i16mf4_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei64_v_i16mf2_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei64_v_i16m1_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei64_v_i16m2_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei64_v_i32mf2_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei64_v_i32m1_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei64_v_i32m2_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei64_v_i32m4_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei64_v_i64m1_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei64_v_i64m2_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei64_v_i64m4_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei64_v_i64m8_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64_v_u8mf8_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64_v_u8mf4_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64_v_u8mf2_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei64_v_u8m1_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64_v_u16mf4_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64_v_u16mf2_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei64_v_u16m1_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei64_v_u16m2_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64_v_u32mf2_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei64_v_u32m1_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei64_v_u32m2_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei64_v_u32m4_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei64_v_u64m1_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei64_v_u64m2_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei64_v_u64m4_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei64_v_u64m8_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64_v_f32mf2_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64_v_f32m1_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64_v_f32m2_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64_v_f32m4_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64_v_f64m1_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64_v_f64m2_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64_v_f64m4_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64_v_f64m8_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m8_tum(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_tumu-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_tumu-1.c
new file mode 100644
index 0000000..a0929b6
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_tumu-1.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei64_v_i8mf8_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei64_v_i8mf4_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei64_v_i8mf2_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei64_v_i8m1_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei64_v_i16mf4_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei64_v_i16mf2_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei64_v_i16m1_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei64_v_i16m2_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei64_v_i32mf2_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei64_v_i32m1_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei64_v_i32m2_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei64_v_i32m4_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei64_v_i64m1_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei64_v_i64m2_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei64_v_i64m4_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei64_v_i64m8_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64_v_u8mf8_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64_v_u8mf4_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64_v_u8mf2_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei64_v_u8m1_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64_v_u16mf4_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64_v_u16mf2_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei64_v_u16m1_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei64_v_u16m2_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64_v_u32mf2_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei64_v_u32m1_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei64_v_u32m2_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei64_v_u32m4_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei64_v_u64m1_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei64_v_u64m2_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei64_v_u64m4_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei64_v_u64m8_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64_v_f32mf2_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64_v_f32m1_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64_v_f32m2_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64_v_f32m4_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64_v_f64m1_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64_v_f64m2_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64_v_f64m4_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64_v_f64m8_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_tumu-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_tumu-2.c
new file mode 100644
index 0000000..13cd2c4
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_tumu-2.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei64_v_i8mf8_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei64_v_i8mf4_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei64_v_i8mf2_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei64_v_i8m1_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei64_v_i16mf4_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei64_v_i16mf2_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei64_v_i16m1_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei64_v_i16m2_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei64_v_i32mf2_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei64_v_i32m1_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei64_v_i32m2_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei64_v_i32m4_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei64_v_i64m1_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei64_v_i64m2_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei64_v_i64m4_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei64_v_i64m8_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64_v_u8mf8_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64_v_u8mf4_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64_v_u8mf2_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei64_v_u8m1_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64_v_u16mf4_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64_v_u16mf2_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei64_v_u16m1_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei64_v_u16m2_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64_v_u32mf2_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei64_v_u32m1_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei64_v_u32m2_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei64_v_u32m4_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei64_v_u64m1_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei64_v_u64m2_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei64_v_u64m4_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei64_v_u64m8_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64_v_f32mf2_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64_v_f32m1_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64_v_f32m2_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64_v_f32m4_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64_v_f64m1_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64_v_f64m2_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64_v_f64m4_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64_v_f64m8_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_tumu-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_tumu-3.c
new file mode 100644
index 0000000..1bc6215
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei64_v_tumu-3.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei64_v_i8mf8_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei64_v_i8mf4_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei64_v_i8mf2_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei64_v_i8m1_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i8m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei64_v_i16mf4_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei64_v_i16mf2_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei64_v_i16m1_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei64_v_i16m2_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i16m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei64_v_i32mf2_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei64_v_i32m1_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei64_v_i32m2_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei64_v_i32m4_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i32m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei64_v_i64m1_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei64_v_i64m2_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei64_v_i64m4_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei64_v_i64m8_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_i64m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei64_v_u8mf8_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei64_v_u8mf4_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei64_v_u8mf2_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei64_v_u8m1_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u8m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei64_v_u16mf4_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei64_v_u16mf2_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei64_v_u16m1_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei64_v_u16m2_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u16m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei64_v_u32mf2_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei64_v_u32m1_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei64_v_u32m2_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei64_v_u32m4_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u32m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei64_v_u64m1_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei64_v_u64m2_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei64_v_u64m4_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei64_v_u64m8_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_u64m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei64_v_f32mf2_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei64_v_f32m1_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei64_v_f32m2_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei64_v_f32m4_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f32m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei64_v_f64m1_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint64m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei64_v_f64m2_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint64m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei64_v_f64m4_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint64m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei64_v_f64m8_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint64m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei64_v_f64m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vluxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v-1.c
new file mode 100644
index 0000000..db54543
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v-1.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei8_v_i8mf8(const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf8(base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei8_v_i8mf4(const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf4(base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei8_v_i8mf2(const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf2(base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei8_v_i8m1(const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m1(base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei8_v_i8m2(const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m2(base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vluxei8_v_i8m4(const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m4(base,bindex,vl);
+}
+
+
+vint8m8_t test___riscv_vluxei8_v_i8m8(const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m8(base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei8_v_i16mf4(const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf4(base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei8_v_i16mf2(const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf2(base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei8_v_i16m1(const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m1(base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei8_v_i16m2(const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m2(base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei8_v_i16m4(const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m4(base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vluxei8_v_i16m8(const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m8(base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei8_v_i32mf2(const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32mf2(base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei8_v_i32m1(const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m1(base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei8_v_i32m2(const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m2(base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei8_v_i32m4(const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m4(base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei8_v_i32m8(const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m8(base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei8_v_i64m1(const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m1(base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei8_v_i64m2(const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m2(base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei8_v_i64m4(const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m4(base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei8_v_i64m8(const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m8(base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8_v_u8mf8(const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf8(base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8_v_u8mf4(const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf4(base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8_v_u8mf2(const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf2(base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei8_v_u8m1(const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m1(base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei8_v_u8m2(const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m2(base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vluxei8_v_u8m4(const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m4(base,bindex,vl);
+}
+
+
+vuint8m8_t test___riscv_vluxei8_v_u8m8(const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m8(base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8_v_u16mf4(const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf4(base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8_v_u16mf2(const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf2(base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei8_v_u16m1(const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m1(base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei8_v_u16m2(const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m2(base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei8_v_u16m4(const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m4(base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vluxei8_v_u16m8(const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m8(base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8_v_u32mf2(const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32mf2(base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei8_v_u32m1(const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m1(base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei8_v_u32m2(const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m2(base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei8_v_u32m4(const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m4(base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei8_v_u32m8(const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m8(base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei8_v_u64m1(const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m1(base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei8_v_u64m2(const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m2(base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei8_v_u64m4(const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m4(base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei8_v_u64m8(const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m8(base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8_v_f32mf2(const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32mf2(base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8_v_f32m1(const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m1(base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8_v_f32m2(const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m2(base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8_v_f32m4(const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m4(base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8_v_f32m8(const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m8(base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8_v_f64m1(const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m1(base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8_v_f64m2(const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m2(base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8_v_f64m4(const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m4(base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8_v_f64m8(const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m8(base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v-2.c
new file mode 100644
index 0000000..6ffad16
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v-2.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei8_v_i8mf8(const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf8(base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei8_v_i8mf4(const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf4(base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei8_v_i8mf2(const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf2(base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei8_v_i8m1(const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m1(base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei8_v_i8m2(const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m2(base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vluxei8_v_i8m4(const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m4(base,bindex,31);
+}
+
+
+vint8m8_t test___riscv_vluxei8_v_i8m8(const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m8(base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei8_v_i16mf4(const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf4(base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei8_v_i16mf2(const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf2(base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei8_v_i16m1(const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m1(base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei8_v_i16m2(const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m2(base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei8_v_i16m4(const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m4(base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vluxei8_v_i16m8(const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m8(base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei8_v_i32mf2(const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32mf2(base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei8_v_i32m1(const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m1(base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei8_v_i32m2(const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m2(base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei8_v_i32m4(const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m4(base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei8_v_i32m8(const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m8(base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei8_v_i64m1(const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m1(base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei8_v_i64m2(const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m2(base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei8_v_i64m4(const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m4(base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei8_v_i64m8(const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m8(base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8_v_u8mf8(const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf8(base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8_v_u8mf4(const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf4(base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8_v_u8mf2(const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf2(base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei8_v_u8m1(const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m1(base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei8_v_u8m2(const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m2(base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vluxei8_v_u8m4(const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m4(base,bindex,31);
+}
+
+
+vuint8m8_t test___riscv_vluxei8_v_u8m8(const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m8(base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8_v_u16mf4(const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf4(base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8_v_u16mf2(const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf2(base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei8_v_u16m1(const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m1(base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei8_v_u16m2(const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m2(base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei8_v_u16m4(const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m4(base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vluxei8_v_u16m8(const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m8(base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8_v_u32mf2(const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32mf2(base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei8_v_u32m1(const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m1(base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei8_v_u32m2(const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m2(base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei8_v_u32m4(const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m4(base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei8_v_u32m8(const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m8(base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei8_v_u64m1(const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m1(base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei8_v_u64m2(const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m2(base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei8_v_u64m4(const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m4(base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei8_v_u64m8(const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m8(base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8_v_f32mf2(const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32mf2(base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8_v_f32m1(const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m1(base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8_v_f32m2(const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m2(base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8_v_f32m4(const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m4(base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8_v_f32m8(const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m8(base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8_v_f64m1(const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m1(base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8_v_f64m2(const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m2(base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8_v_f64m4(const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m4(base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8_v_f64m8(const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m8(base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v-3.c
new file mode 100644
index 0000000..b62cc72
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v-3.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei8_v_i8mf8(const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf8(base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei8_v_i8mf4(const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf4(base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei8_v_i8mf2(const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf2(base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei8_v_i8m1(const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m1(base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei8_v_i8m2(const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m2(base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vluxei8_v_i8m4(const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m4(base,bindex,32);
+}
+
+
+vint8m8_t test___riscv_vluxei8_v_i8m8(const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m8(base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei8_v_i16mf4(const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf4(base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei8_v_i16mf2(const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf2(base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei8_v_i16m1(const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m1(base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei8_v_i16m2(const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m2(base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei8_v_i16m4(const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m4(base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vluxei8_v_i16m8(const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m8(base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei8_v_i32mf2(const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32mf2(base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei8_v_i32m1(const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m1(base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei8_v_i32m2(const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m2(base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei8_v_i32m4(const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m4(base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei8_v_i32m8(const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m8(base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei8_v_i64m1(const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m1(base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei8_v_i64m2(const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m2(base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei8_v_i64m4(const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m4(base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei8_v_i64m8(const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m8(base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8_v_u8mf8(const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf8(base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8_v_u8mf4(const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf4(base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8_v_u8mf2(const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf2(base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei8_v_u8m1(const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m1(base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei8_v_u8m2(const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m2(base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vluxei8_v_u8m4(const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m4(base,bindex,32);
+}
+
+
+vuint8m8_t test___riscv_vluxei8_v_u8m8(const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m8(base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8_v_u16mf4(const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf4(base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8_v_u16mf2(const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf2(base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei8_v_u16m1(const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m1(base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei8_v_u16m2(const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m2(base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei8_v_u16m4(const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m4(base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vluxei8_v_u16m8(const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m8(base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8_v_u32mf2(const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32mf2(base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei8_v_u32m1(const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m1(base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei8_v_u32m2(const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m2(base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei8_v_u32m4(const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m4(base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei8_v_u32m8(const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m8(base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei8_v_u64m1(const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m1(base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei8_v_u64m2(const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m2(base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei8_v_u64m4(const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m4(base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei8_v_u64m8(const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m8(base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8_v_f32mf2(const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32mf2(base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8_v_f32m1(const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m1(base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8_v_f32m2(const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m2(base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8_v_f32m4(const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m4(base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8_v_f32m8(const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m8(base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8_v_f64m1(const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m1(base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8_v_f64m2(const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m2(base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8_v_f64m4(const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m4(base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8_v_f64m8(const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m8(base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_m-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_m-1.c
new file mode 100644
index 0000000..c39182b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_m-1.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei8_v_i8mf8_m(vbool64_t mask,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf8_m(mask,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei8_v_i8mf4_m(vbool32_t mask,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf4_m(mask,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei8_v_i8mf2_m(vbool16_t mask,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf2_m(mask,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei8_v_i8m1_m(vbool8_t mask,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m1_m(mask,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei8_v_i8m2_m(vbool4_t mask,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m2_m(mask,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vluxei8_v_i8m4_m(vbool2_t mask,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m4_m(mask,base,bindex,vl);
+}
+
+
+vint8m8_t test___riscv_vluxei8_v_i8m8_m(vbool1_t mask,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m8_m(mask,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei8_v_i16mf4_m(vbool64_t mask,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf4_m(mask,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei8_v_i16mf2_m(vbool32_t mask,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf2_m(mask,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei8_v_i16m1_m(vbool16_t mask,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m1_m(mask,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei8_v_i16m2_m(vbool8_t mask,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m2_m(mask,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei8_v_i16m4_m(vbool4_t mask,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m4_m(mask,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vluxei8_v_i16m8_m(vbool2_t mask,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m8_m(mask,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei8_v_i32mf2_m(vbool64_t mask,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32mf2_m(mask,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei8_v_i32m1_m(vbool32_t mask,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m1_m(mask,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei8_v_i32m2_m(vbool16_t mask,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m2_m(mask,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei8_v_i32m4_m(vbool8_t mask,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m4_m(mask,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei8_v_i32m8_m(vbool4_t mask,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m8_m(mask,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei8_v_i64m1_m(vbool64_t mask,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m1_m(mask,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei8_v_i64m2_m(vbool32_t mask,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m2_m(mask,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei8_v_i64m4_m(vbool16_t mask,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m4_m(mask,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei8_v_i64m8_m(vbool8_t mask,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m8_m(mask,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8_v_u8mf8_m(vbool64_t mask,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf8_m(mask,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8_v_u8mf4_m(vbool32_t mask,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf4_m(mask,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8_v_u8mf2_m(vbool16_t mask,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf2_m(mask,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei8_v_u8m1_m(vbool8_t mask,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m1_m(mask,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei8_v_u8m2_m(vbool4_t mask,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m2_m(mask,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vluxei8_v_u8m4_m(vbool2_t mask,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m4_m(mask,base,bindex,vl);
+}
+
+
+vuint8m8_t test___riscv_vluxei8_v_u8m8_m(vbool1_t mask,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m8_m(mask,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8_v_u16mf4_m(vbool64_t mask,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf4_m(mask,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8_v_u16mf2_m(vbool32_t mask,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf2_m(mask,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei8_v_u16m1_m(vbool16_t mask,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m1_m(mask,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei8_v_u16m2_m(vbool8_t mask,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m2_m(mask,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei8_v_u16m4_m(vbool4_t mask,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m4_m(mask,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vluxei8_v_u16m8_m(vbool2_t mask,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m8_m(mask,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8_v_u32mf2_m(vbool64_t mask,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32mf2_m(mask,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei8_v_u32m1_m(vbool32_t mask,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m1_m(mask,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei8_v_u32m2_m(vbool16_t mask,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m2_m(mask,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei8_v_u32m4_m(vbool8_t mask,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m4_m(mask,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei8_v_u32m8_m(vbool4_t mask,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m8_m(mask,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei8_v_u64m1_m(vbool64_t mask,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m1_m(mask,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei8_v_u64m2_m(vbool32_t mask,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m2_m(mask,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei8_v_u64m4_m(vbool16_t mask,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m4_m(mask,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei8_v_u64m8_m(vbool8_t mask,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m8_m(mask,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8_v_f32mf2_m(vbool64_t mask,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32mf2_m(mask,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8_v_f32m1_m(vbool32_t mask,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m1_m(mask,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8_v_f32m2_m(vbool16_t mask,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m2_m(mask,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8_v_f32m4_m(vbool8_t mask,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m4_m(mask,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8_v_f32m8_m(vbool4_t mask,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m8_m(mask,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8_v_f64m1_m(vbool64_t mask,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m1_m(mask,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8_v_f64m2_m(vbool32_t mask,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m2_m(mask,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8_v_f64m4_m(vbool16_t mask,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m4_m(mask,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8_v_f64m8_m(vbool8_t mask,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m8_m(mask,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_m-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_m-2.c
new file mode 100644
index 0000000..cccaa70
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_m-2.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei8_v_i8mf8_m(vbool64_t mask,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf8_m(mask,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei8_v_i8mf4_m(vbool32_t mask,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf4_m(mask,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei8_v_i8mf2_m(vbool16_t mask,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf2_m(mask,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei8_v_i8m1_m(vbool8_t mask,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m1_m(mask,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei8_v_i8m2_m(vbool4_t mask,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m2_m(mask,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vluxei8_v_i8m4_m(vbool2_t mask,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m4_m(mask,base,bindex,31);
+}
+
+
+vint8m8_t test___riscv_vluxei8_v_i8m8_m(vbool1_t mask,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m8_m(mask,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei8_v_i16mf4_m(vbool64_t mask,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf4_m(mask,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei8_v_i16mf2_m(vbool32_t mask,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf2_m(mask,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei8_v_i16m1_m(vbool16_t mask,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m1_m(mask,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei8_v_i16m2_m(vbool8_t mask,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m2_m(mask,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei8_v_i16m4_m(vbool4_t mask,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m4_m(mask,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vluxei8_v_i16m8_m(vbool2_t mask,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m8_m(mask,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei8_v_i32mf2_m(vbool64_t mask,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32mf2_m(mask,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei8_v_i32m1_m(vbool32_t mask,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m1_m(mask,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei8_v_i32m2_m(vbool16_t mask,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m2_m(mask,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei8_v_i32m4_m(vbool8_t mask,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m4_m(mask,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei8_v_i32m8_m(vbool4_t mask,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m8_m(mask,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei8_v_i64m1_m(vbool64_t mask,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m1_m(mask,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei8_v_i64m2_m(vbool32_t mask,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m2_m(mask,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei8_v_i64m4_m(vbool16_t mask,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m4_m(mask,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei8_v_i64m8_m(vbool8_t mask,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m8_m(mask,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8_v_u8mf8_m(vbool64_t mask,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf8_m(mask,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8_v_u8mf4_m(vbool32_t mask,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf4_m(mask,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8_v_u8mf2_m(vbool16_t mask,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf2_m(mask,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei8_v_u8m1_m(vbool8_t mask,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m1_m(mask,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei8_v_u8m2_m(vbool4_t mask,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m2_m(mask,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vluxei8_v_u8m4_m(vbool2_t mask,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m4_m(mask,base,bindex,31);
+}
+
+
+vuint8m8_t test___riscv_vluxei8_v_u8m8_m(vbool1_t mask,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m8_m(mask,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8_v_u16mf4_m(vbool64_t mask,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf4_m(mask,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8_v_u16mf2_m(vbool32_t mask,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf2_m(mask,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei8_v_u16m1_m(vbool16_t mask,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m1_m(mask,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei8_v_u16m2_m(vbool8_t mask,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m2_m(mask,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei8_v_u16m4_m(vbool4_t mask,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m4_m(mask,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vluxei8_v_u16m8_m(vbool2_t mask,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m8_m(mask,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8_v_u32mf2_m(vbool64_t mask,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32mf2_m(mask,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei8_v_u32m1_m(vbool32_t mask,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m1_m(mask,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei8_v_u32m2_m(vbool16_t mask,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m2_m(mask,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei8_v_u32m4_m(vbool8_t mask,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m4_m(mask,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei8_v_u32m8_m(vbool4_t mask,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m8_m(mask,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei8_v_u64m1_m(vbool64_t mask,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m1_m(mask,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei8_v_u64m2_m(vbool32_t mask,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m2_m(mask,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei8_v_u64m4_m(vbool16_t mask,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m4_m(mask,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei8_v_u64m8_m(vbool8_t mask,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m8_m(mask,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8_v_f32mf2_m(vbool64_t mask,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32mf2_m(mask,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8_v_f32m1_m(vbool32_t mask,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m1_m(mask,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8_v_f32m2_m(vbool16_t mask,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m2_m(mask,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8_v_f32m4_m(vbool8_t mask,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m4_m(mask,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8_v_f32m8_m(vbool4_t mask,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m8_m(mask,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8_v_f64m1_m(vbool64_t mask,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m1_m(mask,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8_v_f64m2_m(vbool32_t mask,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m2_m(mask,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8_v_f64m4_m(vbool16_t mask,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m4_m(mask,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8_v_f64m8_m(vbool8_t mask,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m8_m(mask,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_m-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_m-3.c
new file mode 100644
index 0000000..916a8d2
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_m-3.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei8_v_i8mf8_m(vbool64_t mask,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf8_m(mask,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei8_v_i8mf4_m(vbool32_t mask,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf4_m(mask,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei8_v_i8mf2_m(vbool16_t mask,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf2_m(mask,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei8_v_i8m1_m(vbool8_t mask,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m1_m(mask,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei8_v_i8m2_m(vbool4_t mask,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m2_m(mask,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vluxei8_v_i8m4_m(vbool2_t mask,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m4_m(mask,base,bindex,32);
+}
+
+
+vint8m8_t test___riscv_vluxei8_v_i8m8_m(vbool1_t mask,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m8_m(mask,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei8_v_i16mf4_m(vbool64_t mask,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf4_m(mask,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei8_v_i16mf2_m(vbool32_t mask,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf2_m(mask,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei8_v_i16m1_m(vbool16_t mask,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m1_m(mask,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei8_v_i16m2_m(vbool8_t mask,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m2_m(mask,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei8_v_i16m4_m(vbool4_t mask,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m4_m(mask,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vluxei8_v_i16m8_m(vbool2_t mask,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m8_m(mask,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei8_v_i32mf2_m(vbool64_t mask,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32mf2_m(mask,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei8_v_i32m1_m(vbool32_t mask,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m1_m(mask,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei8_v_i32m2_m(vbool16_t mask,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m2_m(mask,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei8_v_i32m4_m(vbool8_t mask,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m4_m(mask,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei8_v_i32m8_m(vbool4_t mask,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m8_m(mask,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei8_v_i64m1_m(vbool64_t mask,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m1_m(mask,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei8_v_i64m2_m(vbool32_t mask,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m2_m(mask,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei8_v_i64m4_m(vbool16_t mask,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m4_m(mask,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei8_v_i64m8_m(vbool8_t mask,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m8_m(mask,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8_v_u8mf8_m(vbool64_t mask,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf8_m(mask,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8_v_u8mf4_m(vbool32_t mask,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf4_m(mask,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8_v_u8mf2_m(vbool16_t mask,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf2_m(mask,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei8_v_u8m1_m(vbool8_t mask,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m1_m(mask,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei8_v_u8m2_m(vbool4_t mask,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m2_m(mask,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vluxei8_v_u8m4_m(vbool2_t mask,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m4_m(mask,base,bindex,32);
+}
+
+
+vuint8m8_t test___riscv_vluxei8_v_u8m8_m(vbool1_t mask,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m8_m(mask,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8_v_u16mf4_m(vbool64_t mask,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf4_m(mask,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8_v_u16mf2_m(vbool32_t mask,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf2_m(mask,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei8_v_u16m1_m(vbool16_t mask,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m1_m(mask,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei8_v_u16m2_m(vbool8_t mask,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m2_m(mask,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei8_v_u16m4_m(vbool4_t mask,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m4_m(mask,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vluxei8_v_u16m8_m(vbool2_t mask,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m8_m(mask,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8_v_u32mf2_m(vbool64_t mask,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32mf2_m(mask,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei8_v_u32m1_m(vbool32_t mask,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m1_m(mask,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei8_v_u32m2_m(vbool16_t mask,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m2_m(mask,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei8_v_u32m4_m(vbool8_t mask,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m4_m(mask,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei8_v_u32m8_m(vbool4_t mask,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m8_m(mask,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei8_v_u64m1_m(vbool64_t mask,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m1_m(mask,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei8_v_u64m2_m(vbool32_t mask,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m2_m(mask,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei8_v_u64m4_m(vbool16_t mask,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m4_m(mask,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei8_v_u64m8_m(vbool8_t mask,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m8_m(mask,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8_v_f32mf2_m(vbool64_t mask,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32mf2_m(mask,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8_v_f32m1_m(vbool32_t mask,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m1_m(mask,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8_v_f32m2_m(vbool16_t mask,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m2_m(mask,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8_v_f32m4_m(vbool8_t mask,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m4_m(mask,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8_v_f32m8_m(vbool4_t mask,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m8_m(mask,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8_v_f64m1_m(vbool64_t mask,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m1_m(mask,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8_v_f64m2_m(vbool32_t mask,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m2_m(mask,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8_v_f64m4_m(vbool16_t mask,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m4_m(mask,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8_v_f64m8_m(vbool8_t mask,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m8_m(mask,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_mu-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_mu-1.c
new file mode 100644
index 0000000..4246ff2
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_mu-1.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei8_v_i8mf8_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei8_v_i8mf4_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei8_v_i8mf2_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei8_v_i8m1_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei8_v_i8m2_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vluxei8_v_i8m4_mu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m8_t test___riscv_vluxei8_v_i8m8_mu(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei8_v_i16mf4_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei8_v_i16mf2_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei8_v_i16m1_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei8_v_i16m2_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei8_v_i16m4_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vluxei8_v_i16m8_mu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei8_v_i32mf2_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei8_v_i32m1_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei8_v_i32m2_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei8_v_i32m4_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei8_v_i32m8_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei8_v_i64m1_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei8_v_i64m2_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei8_v_i64m4_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei8_v_i64m8_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8_v_u8mf8_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8_v_u8mf4_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8_v_u8mf2_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei8_v_u8m1_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei8_v_u8m2_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vluxei8_v_u8m4_mu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m8_t test___riscv_vluxei8_v_u8m8_mu(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8_v_u16mf4_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8_v_u16mf2_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei8_v_u16m1_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei8_v_u16m2_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei8_v_u16m4_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vluxei8_v_u16m8_mu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8_v_u32mf2_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei8_v_u32m1_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei8_v_u32m2_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei8_v_u32m4_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei8_v_u32m8_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei8_v_u64m1_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei8_v_u64m2_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei8_v_u64m4_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei8_v_u64m8_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8_v_f32mf2_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32mf2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8_v_f32m1_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8_v_f32m2_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8_v_f32m4_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8_v_f32m8_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8_v_f64m1_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m1_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8_v_f64m2_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m2_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8_v_f64m4_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m4_mu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8_v_f64m8_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m8_mu(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_mu-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_mu-2.c
new file mode 100644
index 0000000..78c779e
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_mu-2.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei8_v_i8mf8_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei8_v_i8mf4_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei8_v_i8mf2_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei8_v_i8m1_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei8_v_i8m2_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vluxei8_v_i8m4_mu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint8m8_t test___riscv_vluxei8_v_i8m8_mu(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei8_v_i16mf4_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei8_v_i16mf2_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei8_v_i16m1_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei8_v_i16m2_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei8_v_i16m4_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vluxei8_v_i16m8_mu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei8_v_i32mf2_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei8_v_i32m1_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei8_v_i32m2_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei8_v_i32m4_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei8_v_i32m8_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei8_v_i64m1_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei8_v_i64m2_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei8_v_i64m4_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei8_v_i64m8_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8_v_u8mf8_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8_v_u8mf4_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8_v_u8mf2_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei8_v_u8m1_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei8_v_u8m2_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vluxei8_v_u8m4_mu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m8_t test___riscv_vluxei8_v_u8m8_mu(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8_v_u16mf4_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8_v_u16mf2_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei8_v_u16m1_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei8_v_u16m2_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei8_v_u16m4_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vluxei8_v_u16m8_mu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8_v_u32mf2_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei8_v_u32m1_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei8_v_u32m2_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei8_v_u32m4_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei8_v_u32m8_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei8_v_u64m1_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei8_v_u64m2_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei8_v_u64m4_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei8_v_u64m8_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8_v_f32mf2_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32mf2_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8_v_f32m1_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8_v_f32m2_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8_v_f32m4_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8_v_f32m8_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m8_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8_v_f64m1_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m1_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8_v_f64m2_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m2_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8_v_f64m4_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m4_mu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8_v_f64m8_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m8_mu(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_mu-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_mu-3.c
new file mode 100644
index 0000000..304d0fc
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_mu-3.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei8_v_i8mf8_mu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei8_v_i8mf4_mu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei8_v_i8mf2_mu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei8_v_i8m1_mu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei8_v_i8m2_mu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vluxei8_v_i8m4_mu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint8m8_t test___riscv_vluxei8_v_i8m8_mu(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei8_v_i16mf4_mu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei8_v_i16mf2_mu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei8_v_i16m1_mu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei8_v_i16m2_mu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei8_v_i16m4_mu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vluxei8_v_i16m8_mu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei8_v_i32mf2_mu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei8_v_i32m1_mu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei8_v_i32m2_mu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei8_v_i32m4_mu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei8_v_i32m8_mu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei8_v_i64m1_mu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei8_v_i64m2_mu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei8_v_i64m4_mu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei8_v_i64m8_mu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8_v_u8mf8_mu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8_v_u8mf4_mu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8_v_u8mf2_mu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei8_v_u8m1_mu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei8_v_u8m2_mu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vluxei8_v_u8m4_mu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m8_t test___riscv_vluxei8_v_u8m8_mu(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8_v_u16mf4_mu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8_v_u16mf2_mu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei8_v_u16m1_mu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei8_v_u16m2_mu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei8_v_u16m4_mu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vluxei8_v_u16m8_mu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8_v_u32mf2_mu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei8_v_u32m1_mu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei8_v_u32m2_mu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei8_v_u32m4_mu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei8_v_u32m8_mu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei8_v_u64m1_mu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei8_v_u64m2_mu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei8_v_u64m4_mu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei8_v_u64m8_mu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8_v_f32mf2_mu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32mf2_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8_v_f32m1_mu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8_v_f32m2_mu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8_v_f32m4_mu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8_v_f32m8_mu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m8_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8_v_f64m1_mu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m1_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8_v_f64m2_mu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m2_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8_v_f64m4_mu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m4_mu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8_v_f64m8_mu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m8_mu(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_tu-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_tu-1.c
new file mode 100644
index 0000000..1c8e2072
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_tu-1.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei8_v_i8mf8_tu(vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf8_tu(merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei8_v_i8mf4_tu(vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf4_tu(merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei8_v_i8mf2_tu(vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf2_tu(merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei8_v_i8m1_tu(vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m1_tu(merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei8_v_i8m2_tu(vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m2_tu(merge,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vluxei8_v_i8m4_tu(vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m4_tu(merge,base,bindex,vl);
+}
+
+
+vint8m8_t test___riscv_vluxei8_v_i8m8_tu(vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m8_tu(merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei8_v_i16mf4_tu(vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf4_tu(merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei8_v_i16mf2_tu(vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf2_tu(merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei8_v_i16m1_tu(vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m1_tu(merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei8_v_i16m2_tu(vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m2_tu(merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei8_v_i16m4_tu(vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m4_tu(merge,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vluxei8_v_i16m8_tu(vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m8_tu(merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei8_v_i32mf2_tu(vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32mf2_tu(merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei8_v_i32m1_tu(vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m1_tu(merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei8_v_i32m2_tu(vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m2_tu(merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei8_v_i32m4_tu(vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m4_tu(merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei8_v_i32m8_tu(vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m8_tu(merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei8_v_i64m1_tu(vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m1_tu(merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei8_v_i64m2_tu(vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m2_tu(merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei8_v_i64m4_tu(vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m4_tu(merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei8_v_i64m8_tu(vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m8_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8_v_u8mf8_tu(vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf8_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8_v_u8mf4_tu(vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf4_tu(merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8_v_u8mf2_tu(vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf2_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei8_v_u8m1_tu(vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m1_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei8_v_u8m2_tu(vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m2_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vluxei8_v_u8m4_tu(vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m4_tu(merge,base,bindex,vl);
+}
+
+
+vuint8m8_t test___riscv_vluxei8_v_u8m8_tu(vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m8_tu(merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8_v_u16mf4_tu(vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf4_tu(merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8_v_u16mf2_tu(vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf2_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei8_v_u16m1_tu(vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m1_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei8_v_u16m2_tu(vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m2_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei8_v_u16m4_tu(vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m4_tu(merge,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vluxei8_v_u16m8_tu(vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m8_tu(merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8_v_u32mf2_tu(vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32mf2_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei8_v_u32m1_tu(vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m1_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei8_v_u32m2_tu(vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m2_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei8_v_u32m4_tu(vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m4_tu(merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei8_v_u32m8_tu(vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m8_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei8_v_u64m1_tu(vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m1_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei8_v_u64m2_tu(vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m2_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei8_v_u64m4_tu(vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m4_tu(merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei8_v_u64m8_tu(vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m8_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8_v_f32mf2_tu(vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32mf2_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8_v_f32m1_tu(vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m1_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8_v_f32m2_tu(vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m2_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8_v_f32m4_tu(vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m4_tu(merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8_v_f32m8_tu(vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m8_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8_v_f64m1_tu(vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m1_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8_v_f64m2_tu(vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m2_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8_v_f64m4_tu(vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m4_tu(merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8_v_f64m8_tu(vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m8_tu(merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_tu-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_tu-2.c
new file mode 100644
index 0000000..f3a9c65
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_tu-2.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei8_v_i8mf8_tu(vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf8_tu(merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei8_v_i8mf4_tu(vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf4_tu(merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei8_v_i8mf2_tu(vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf2_tu(merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei8_v_i8m1_tu(vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m1_tu(merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei8_v_i8m2_tu(vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m2_tu(merge,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vluxei8_v_i8m4_tu(vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m4_tu(merge,base,bindex,31);
+}
+
+
+vint8m8_t test___riscv_vluxei8_v_i8m8_tu(vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m8_tu(merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei8_v_i16mf4_tu(vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf4_tu(merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei8_v_i16mf2_tu(vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf2_tu(merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei8_v_i16m1_tu(vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m1_tu(merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei8_v_i16m2_tu(vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m2_tu(merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei8_v_i16m4_tu(vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m4_tu(merge,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vluxei8_v_i16m8_tu(vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m8_tu(merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei8_v_i32mf2_tu(vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32mf2_tu(merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei8_v_i32m1_tu(vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m1_tu(merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei8_v_i32m2_tu(vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m2_tu(merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei8_v_i32m4_tu(vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m4_tu(merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei8_v_i32m8_tu(vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m8_tu(merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei8_v_i64m1_tu(vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m1_tu(merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei8_v_i64m2_tu(vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m2_tu(merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei8_v_i64m4_tu(vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m4_tu(merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei8_v_i64m8_tu(vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m8_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8_v_u8mf8_tu(vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf8_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8_v_u8mf4_tu(vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf4_tu(merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8_v_u8mf2_tu(vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf2_tu(merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei8_v_u8m1_tu(vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m1_tu(merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei8_v_u8m2_tu(vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m2_tu(merge,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vluxei8_v_u8m4_tu(vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m4_tu(merge,base,bindex,31);
+}
+
+
+vuint8m8_t test___riscv_vluxei8_v_u8m8_tu(vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m8_tu(merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8_v_u16mf4_tu(vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf4_tu(merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8_v_u16mf2_tu(vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf2_tu(merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei8_v_u16m1_tu(vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m1_tu(merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei8_v_u16m2_tu(vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m2_tu(merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei8_v_u16m4_tu(vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m4_tu(merge,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vluxei8_v_u16m8_tu(vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m8_tu(merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8_v_u32mf2_tu(vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32mf2_tu(merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei8_v_u32m1_tu(vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m1_tu(merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei8_v_u32m2_tu(vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m2_tu(merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei8_v_u32m4_tu(vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m4_tu(merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei8_v_u32m8_tu(vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m8_tu(merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei8_v_u64m1_tu(vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m1_tu(merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei8_v_u64m2_tu(vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m2_tu(merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei8_v_u64m4_tu(vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m4_tu(merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei8_v_u64m8_tu(vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m8_tu(merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8_v_f32mf2_tu(vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32mf2_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8_v_f32m1_tu(vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m1_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8_v_f32m2_tu(vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m2_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8_v_f32m4_tu(vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m4_tu(merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8_v_f32m8_tu(vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m8_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8_v_f64m1_tu(vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m1_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8_v_f64m2_tu(vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m2_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8_v_f64m4_tu(vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m4_tu(merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8_v_f64m8_tu(vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m8_tu(merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_tu-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_tu-3.c
new file mode 100644
index 0000000..2c4687d
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_tu-3.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei8_v_i8mf8_tu(vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf8_tu(merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei8_v_i8mf4_tu(vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf4_tu(merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei8_v_i8mf2_tu(vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf2_tu(merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei8_v_i8m1_tu(vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m1_tu(merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei8_v_i8m2_tu(vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m2_tu(merge,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vluxei8_v_i8m4_tu(vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m4_tu(merge,base,bindex,32);
+}
+
+
+vint8m8_t test___riscv_vluxei8_v_i8m8_tu(vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m8_tu(merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei8_v_i16mf4_tu(vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf4_tu(merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei8_v_i16mf2_tu(vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf2_tu(merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei8_v_i16m1_tu(vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m1_tu(merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei8_v_i16m2_tu(vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m2_tu(merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei8_v_i16m4_tu(vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m4_tu(merge,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vluxei8_v_i16m8_tu(vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m8_tu(merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei8_v_i32mf2_tu(vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32mf2_tu(merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei8_v_i32m1_tu(vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m1_tu(merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei8_v_i32m2_tu(vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m2_tu(merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei8_v_i32m4_tu(vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m4_tu(merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei8_v_i32m8_tu(vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m8_tu(merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei8_v_i64m1_tu(vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m1_tu(merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei8_v_i64m2_tu(vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m2_tu(merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei8_v_i64m4_tu(vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m4_tu(merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei8_v_i64m8_tu(vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m8_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8_v_u8mf8_tu(vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf8_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8_v_u8mf4_tu(vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf4_tu(merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8_v_u8mf2_tu(vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf2_tu(merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei8_v_u8m1_tu(vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m1_tu(merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei8_v_u8m2_tu(vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m2_tu(merge,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vluxei8_v_u8m4_tu(vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m4_tu(merge,base,bindex,32);
+}
+
+
+vuint8m8_t test___riscv_vluxei8_v_u8m8_tu(vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m8_tu(merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8_v_u16mf4_tu(vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf4_tu(merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8_v_u16mf2_tu(vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf2_tu(merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei8_v_u16m1_tu(vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m1_tu(merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei8_v_u16m2_tu(vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m2_tu(merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei8_v_u16m4_tu(vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m4_tu(merge,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vluxei8_v_u16m8_tu(vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m8_tu(merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8_v_u32mf2_tu(vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32mf2_tu(merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei8_v_u32m1_tu(vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m1_tu(merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei8_v_u32m2_tu(vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m2_tu(merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei8_v_u32m4_tu(vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m4_tu(merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei8_v_u32m8_tu(vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m8_tu(merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei8_v_u64m1_tu(vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m1_tu(merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei8_v_u64m2_tu(vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m2_tu(merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei8_v_u64m4_tu(vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m4_tu(merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei8_v_u64m8_tu(vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m8_tu(merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8_v_f32mf2_tu(vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32mf2_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8_v_f32m1_tu(vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m1_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8_v_f32m2_tu(vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m2_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8_v_f32m4_tu(vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m4_tu(merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8_v_f32m8_tu(vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m8_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8_v_f64m1_tu(vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m1_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8_v_f64m2_tu(vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m2_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8_v_f64m4_tu(vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m4_tu(merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8_v_f64m8_tu(vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m8_tu(merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_tum-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_tum-1.c
new file mode 100644
index 0000000..7540ec7
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_tum-1.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei8_v_i8mf8_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei8_v_i8mf4_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei8_v_i8mf2_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei8_v_i8m1_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei8_v_i8m2_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vluxei8_v_i8m4_tum(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint8m8_t test___riscv_vluxei8_v_i8m8_tum(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei8_v_i16mf4_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei8_v_i16mf2_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei8_v_i16m1_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei8_v_i16m2_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei8_v_i16m4_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vluxei8_v_i16m8_tum(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei8_v_i32mf2_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei8_v_i32m1_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei8_v_i32m2_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei8_v_i32m4_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei8_v_i32m8_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei8_v_i64m1_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei8_v_i64m2_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei8_v_i64m4_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei8_v_i64m8_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8_v_u8mf8_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8_v_u8mf4_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8_v_u8mf2_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei8_v_u8m1_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei8_v_u8m2_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vluxei8_v_u8m4_tum(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m8_t test___riscv_vluxei8_v_u8m8_tum(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8_v_u16mf4_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8_v_u16mf2_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei8_v_u16m1_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei8_v_u16m2_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei8_v_u16m4_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vluxei8_v_u16m8_tum(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8_v_u32mf2_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei8_v_u32m1_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei8_v_u32m2_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei8_v_u32m4_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei8_v_u32m8_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei8_v_u64m1_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei8_v_u64m2_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei8_v_u64m4_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei8_v_u64m8_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8_v_f32mf2_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32mf2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8_v_f32m1_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8_v_f32m2_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8_v_f32m4_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8_v_f32m8_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8_v_f64m1_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m1_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8_v_f64m2_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m2_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8_v_f64m4_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m4_tum(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8_v_f64m8_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m8_tum(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_tum-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_tum-2.c
new file mode 100644
index 0000000..9496a68
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_tum-2.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei8_v_i8mf8_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei8_v_i8mf4_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei8_v_i8mf2_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei8_v_i8m1_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei8_v_i8m2_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vluxei8_v_i8m4_tum(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint8m8_t test___riscv_vluxei8_v_i8m8_tum(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei8_v_i16mf4_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei8_v_i16mf2_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei8_v_i16m1_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei8_v_i16m2_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei8_v_i16m4_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vluxei8_v_i16m8_tum(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei8_v_i32mf2_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei8_v_i32m1_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei8_v_i32m2_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei8_v_i32m4_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei8_v_i32m8_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei8_v_i64m1_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei8_v_i64m2_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei8_v_i64m4_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei8_v_i64m8_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8_v_u8mf8_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8_v_u8mf4_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8_v_u8mf2_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei8_v_u8m1_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei8_v_u8m2_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vluxei8_v_u8m4_tum(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint8m8_t test___riscv_vluxei8_v_u8m8_tum(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8_v_u16mf4_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8_v_u16mf2_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei8_v_u16m1_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei8_v_u16m2_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei8_v_u16m4_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vluxei8_v_u16m8_tum(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8_v_u32mf2_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei8_v_u32m1_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei8_v_u32m2_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei8_v_u32m4_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei8_v_u32m8_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei8_v_u64m1_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei8_v_u64m2_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei8_v_u64m4_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei8_v_u64m8_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8_v_f32mf2_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32mf2_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8_v_f32m1_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8_v_f32m2_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8_v_f32m4_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8_v_f32m8_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m8_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8_v_f64m1_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m1_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8_v_f64m2_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m2_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8_v_f64m4_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m4_tum(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8_v_f64m8_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m8_tum(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_tum-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_tum-3.c
new file mode 100644
index 0000000..0491f45
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_tum-3.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei8_v_i8mf8_tum(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei8_v_i8mf4_tum(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei8_v_i8mf2_tum(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei8_v_i8m1_tum(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei8_v_i8m2_tum(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vluxei8_v_i8m4_tum(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint8m8_t test___riscv_vluxei8_v_i8m8_tum(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei8_v_i16mf4_tum(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei8_v_i16mf2_tum(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei8_v_i16m1_tum(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei8_v_i16m2_tum(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei8_v_i16m4_tum(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vluxei8_v_i16m8_tum(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei8_v_i32mf2_tum(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei8_v_i32m1_tum(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei8_v_i32m2_tum(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei8_v_i32m4_tum(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei8_v_i32m8_tum(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei8_v_i64m1_tum(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei8_v_i64m2_tum(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei8_v_i64m4_tum(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei8_v_i64m8_tum(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8_v_u8mf8_tum(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8_v_u8mf4_tum(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8_v_u8mf2_tum(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei8_v_u8m1_tum(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei8_v_u8m2_tum(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vluxei8_v_u8m4_tum(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint8m8_t test___riscv_vluxei8_v_u8m8_tum(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8_v_u16mf4_tum(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8_v_u16mf2_tum(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei8_v_u16m1_tum(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei8_v_u16m2_tum(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei8_v_u16m4_tum(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vluxei8_v_u16m8_tum(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8_v_u32mf2_tum(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei8_v_u32m1_tum(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei8_v_u32m2_tum(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei8_v_u32m4_tum(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei8_v_u32m8_tum(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei8_v_u64m1_tum(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei8_v_u64m2_tum(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei8_v_u64m4_tum(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei8_v_u64m8_tum(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8_v_f32mf2_tum(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32mf2_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8_v_f32m1_tum(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8_v_f32m2_tum(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8_v_f32m4_tum(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8_v_f32m8_tum(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m8_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8_v_f64m1_tum(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m1_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8_v_f64m2_tum(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m2_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8_v_f64m4_tum(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m4_tum(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8_v_f64m8_tum(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m8_tum(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*m[au]\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_tumu-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_tumu-1.c
new file mode 100644
index 0000000..52cf4dd
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_tumu-1.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei8_v_i8mf8_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf4_t test___riscv_vluxei8_v_i8mf4_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8mf2_t test___riscv_vluxei8_v_i8mf2_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m1_t test___riscv_vluxei8_v_i8m1_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m2_t test___riscv_vluxei8_v_i8m2_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m4_t test___riscv_vluxei8_v_i8m4_tumu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint8m8_t test___riscv_vluxei8_v_i8m8_tumu(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf4_t test___riscv_vluxei8_v_i16mf4_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16mf2_t test___riscv_vluxei8_v_i16mf2_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m1_t test___riscv_vluxei8_v_i16m1_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m2_t test___riscv_vluxei8_v_i16m2_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m4_t test___riscv_vluxei8_v_i16m4_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint16m8_t test___riscv_vluxei8_v_i16m8_tumu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32mf2_t test___riscv_vluxei8_v_i32mf2_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m1_t test___riscv_vluxei8_v_i32m1_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m2_t test___riscv_vluxei8_v_i32m2_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m4_t test___riscv_vluxei8_v_i32m4_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint32m8_t test___riscv_vluxei8_v_i32m8_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m1_t test___riscv_vluxei8_v_i64m1_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m2_t test___riscv_vluxei8_v_i64m2_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m4_t test___riscv_vluxei8_v_i64m4_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vint64m8_t test___riscv_vluxei8_v_i64m8_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8_v_u8mf8_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8_v_u8mf4_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8_v_u8mf2_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m1_t test___riscv_vluxei8_v_u8m1_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m2_t test___riscv_vluxei8_v_u8m2_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m4_t test___riscv_vluxei8_v_u8m4_tumu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint8m8_t test___riscv_vluxei8_v_u8m8_tumu(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8_v_u16mf4_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8_v_u16mf2_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m1_t test___riscv_vluxei8_v_u16m1_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m2_t test___riscv_vluxei8_v_u16m2_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m4_t test___riscv_vluxei8_v_u16m4_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint16m8_t test___riscv_vluxei8_v_u16m8_tumu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8_v_u32mf2_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m1_t test___riscv_vluxei8_v_u32m1_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m2_t test___riscv_vluxei8_v_u32m2_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m4_t test___riscv_vluxei8_v_u32m4_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint32m8_t test___riscv_vluxei8_v_u32m8_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m1_t test___riscv_vluxei8_v_u64m1_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m2_t test___riscv_vluxei8_v_u64m2_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m4_t test___riscv_vluxei8_v_u64m4_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vuint64m8_t test___riscv_vluxei8_v_u64m8_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8_v_f32mf2_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32mf2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8_v_f32m1_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8_v_f32m2_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8_v_f32m4_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8_v_f32m8_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8_v_f64m1_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m1_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8_v_f64m2_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m2_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8_v_f64m4_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m4_tumu(mask,merge,base,bindex,vl);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8_v_f64m8_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m8_tumu(mask,merge,base,bindex,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_tumu-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_tumu-2.c
new file mode 100644
index 0000000..b7f5840
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_tumu-2.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei8_v_i8mf8_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf4_t test___riscv_vluxei8_v_i8mf4_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8mf2_t test___riscv_vluxei8_v_i8mf2_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m1_t test___riscv_vluxei8_v_i8m1_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m2_t test___riscv_vluxei8_v_i8m2_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m4_t test___riscv_vluxei8_v_i8m4_tumu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint8m8_t test___riscv_vluxei8_v_i8m8_tumu(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf4_t test___riscv_vluxei8_v_i16mf4_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16mf2_t test___riscv_vluxei8_v_i16mf2_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m1_t test___riscv_vluxei8_v_i16m1_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m2_t test___riscv_vluxei8_v_i16m2_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m4_t test___riscv_vluxei8_v_i16m4_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint16m8_t test___riscv_vluxei8_v_i16m8_tumu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32mf2_t test___riscv_vluxei8_v_i32mf2_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m1_t test___riscv_vluxei8_v_i32m1_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m2_t test___riscv_vluxei8_v_i32m2_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m4_t test___riscv_vluxei8_v_i32m4_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint32m8_t test___riscv_vluxei8_v_i32m8_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m1_t test___riscv_vluxei8_v_i64m1_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m2_t test___riscv_vluxei8_v_i64m2_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m4_t test___riscv_vluxei8_v_i64m4_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vint64m8_t test___riscv_vluxei8_v_i64m8_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8_v_u8mf8_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8_v_u8mf4_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8_v_u8mf2_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m1_t test___riscv_vluxei8_v_u8m1_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m2_t test___riscv_vluxei8_v_u8m2_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m4_t test___riscv_vluxei8_v_u8m4_tumu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint8m8_t test___riscv_vluxei8_v_u8m8_tumu(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8_v_u16mf4_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8_v_u16mf2_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m1_t test___riscv_vluxei8_v_u16m1_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m2_t test___riscv_vluxei8_v_u16m2_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m4_t test___riscv_vluxei8_v_u16m4_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint16m8_t test___riscv_vluxei8_v_u16m8_tumu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8_v_u32mf2_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m1_t test___riscv_vluxei8_v_u32m1_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m2_t test___riscv_vluxei8_v_u32m2_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m4_t test___riscv_vluxei8_v_u32m4_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint32m8_t test___riscv_vluxei8_v_u32m8_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m1_t test___riscv_vluxei8_v_u64m1_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m2_t test___riscv_vluxei8_v_u64m2_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m4_t test___riscv_vluxei8_v_u64m4_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vuint64m8_t test___riscv_vluxei8_v_u64m8_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8_v_f32mf2_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32mf2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8_v_f32m1_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8_v_f32m2_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8_v_f32m4_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8_v_f32m8_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8_v_f64m1_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m1_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8_v_f64m2_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m2_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8_v_f64m4_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m4_tumu(mask,merge,base,bindex,31);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8_v_f64m8_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m8_tumu(mask,merge,base,bindex,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_tumu-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_tumu-3.c
new file mode 100644
index 0000000..809497f
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vluxei8_v_tumu-3.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+vint8mf8_t test___riscv_vluxei8_v_i8mf8_tumu(vbool64_t mask,vint8mf8_t merge,const int8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf4_t test___riscv_vluxei8_v_i8mf4_tumu(vbool32_t mask,vint8mf4_t merge,const int8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8mf2_t test___riscv_vluxei8_v_i8mf2_tumu(vbool16_t mask,vint8mf2_t merge,const int8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m1_t test___riscv_vluxei8_v_i8m1_tumu(vbool8_t mask,vint8m1_t merge,const int8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m2_t test___riscv_vluxei8_v_i8m2_tumu(vbool4_t mask,vint8m2_t merge,const int8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m4_t test___riscv_vluxei8_v_i8m4_tumu(vbool2_t mask,vint8m4_t merge,const int8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint8m8_t test___riscv_vluxei8_v_i8m8_tumu(vbool1_t mask,vint8m8_t merge,const int8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i8m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf4_t test___riscv_vluxei8_v_i16mf4_tumu(vbool64_t mask,vint16mf4_t merge,const int16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16mf2_t test___riscv_vluxei8_v_i16mf2_tumu(vbool32_t mask,vint16mf2_t merge,const int16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m1_t test___riscv_vluxei8_v_i16m1_tumu(vbool16_t mask,vint16m1_t merge,const int16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m2_t test___riscv_vluxei8_v_i16m2_tumu(vbool8_t mask,vint16m2_t merge,const int16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m4_t test___riscv_vluxei8_v_i16m4_tumu(vbool4_t mask,vint16m4_t merge,const int16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint16m8_t test___riscv_vluxei8_v_i16m8_tumu(vbool2_t mask,vint16m8_t merge,const int16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i16m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32mf2_t test___riscv_vluxei8_v_i32mf2_tumu(vbool64_t mask,vint32mf2_t merge,const int32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m1_t test___riscv_vluxei8_v_i32m1_tumu(vbool32_t mask,vint32m1_t merge,const int32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m2_t test___riscv_vluxei8_v_i32m2_tumu(vbool16_t mask,vint32m2_t merge,const int32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m4_t test___riscv_vluxei8_v_i32m4_tumu(vbool8_t mask,vint32m4_t merge,const int32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint32m8_t test___riscv_vluxei8_v_i32m8_tumu(vbool4_t mask,vint32m8_t merge,const int32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i32m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m1_t test___riscv_vluxei8_v_i64m1_tumu(vbool64_t mask,vint64m1_t merge,const int64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m2_t test___riscv_vluxei8_v_i64m2_tumu(vbool32_t mask,vint64m2_t merge,const int64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m4_t test___riscv_vluxei8_v_i64m4_tumu(vbool16_t mask,vint64m4_t merge,const int64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vint64m8_t test___riscv_vluxei8_v_i64m8_tumu(vbool8_t mask,vint64m8_t merge,const int64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_i64m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf8_t test___riscv_vluxei8_v_u8mf8_tumu(vbool64_t mask,vuint8mf8_t merge,const uint8_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf4_t test___riscv_vluxei8_v_u8mf4_tumu(vbool32_t mask,vuint8mf4_t merge,const uint8_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8mf2_t test___riscv_vluxei8_v_u8mf2_tumu(vbool16_t mask,vuint8mf2_t merge,const uint8_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m1_t test___riscv_vluxei8_v_u8m1_tumu(vbool8_t mask,vuint8m1_t merge,const uint8_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m2_t test___riscv_vluxei8_v_u8m2_tumu(vbool4_t mask,vuint8m2_t merge,const uint8_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m4_t test___riscv_vluxei8_v_u8m4_tumu(vbool2_t mask,vuint8m4_t merge,const uint8_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint8m8_t test___riscv_vluxei8_v_u8m8_tumu(vbool1_t mask,vuint8m8_t merge,const uint8_t* base,vuint8m8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u8m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf4_t test___riscv_vluxei8_v_u16mf4_tumu(vbool64_t mask,vuint16mf4_t merge,const uint16_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16mf2_t test___riscv_vluxei8_v_u16mf2_tumu(vbool32_t mask,vuint16mf2_t merge,const uint16_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m1_t test___riscv_vluxei8_v_u16m1_tumu(vbool16_t mask,vuint16m1_t merge,const uint16_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m2_t test___riscv_vluxei8_v_u16m2_tumu(vbool8_t mask,vuint16m2_t merge,const uint16_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m4_t test___riscv_vluxei8_v_u16m4_tumu(vbool4_t mask,vuint16m4_t merge,const uint16_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint16m8_t test___riscv_vluxei8_v_u16m8_tumu(vbool2_t mask,vuint16m8_t merge,const uint16_t* base,vuint8m4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u16m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32mf2_t test___riscv_vluxei8_v_u32mf2_tumu(vbool64_t mask,vuint32mf2_t merge,const uint32_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m1_t test___riscv_vluxei8_v_u32m1_tumu(vbool32_t mask,vuint32m1_t merge,const uint32_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m2_t test___riscv_vluxei8_v_u32m2_tumu(vbool16_t mask,vuint32m2_t merge,const uint32_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m4_t test___riscv_vluxei8_v_u32m4_tumu(vbool8_t mask,vuint32m4_t merge,const uint32_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint32m8_t test___riscv_vluxei8_v_u32m8_tumu(vbool4_t mask,vuint32m8_t merge,const uint32_t* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u32m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m1_t test___riscv_vluxei8_v_u64m1_tumu(vbool64_t mask,vuint64m1_t merge,const uint64_t* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m2_t test___riscv_vluxei8_v_u64m2_tumu(vbool32_t mask,vuint64m2_t merge,const uint64_t* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m4_t test___riscv_vluxei8_v_u64m4_tumu(vbool16_t mask,vuint64m4_t merge,const uint64_t* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vuint64m8_t test___riscv_vluxei8_v_u64m8_tumu(vbool8_t mask,vuint64m8_t merge,const uint64_t* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_u64m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32mf2_t test___riscv_vluxei8_v_f32mf2_tumu(vbool64_t mask,vfloat32mf2_t merge,const float* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32mf2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m1_t test___riscv_vluxei8_v_f32m1_tumu(vbool32_t mask,vfloat32m1_t merge,const float* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m2_t test___riscv_vluxei8_v_f32m2_tumu(vbool16_t mask,vfloat32m2_t merge,const float* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m4_t test___riscv_vluxei8_v_f32m4_tumu(vbool8_t mask,vfloat32m4_t merge,const float* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat32m8_t test___riscv_vluxei8_v_f32m8_tumu(vbool4_t mask,vfloat32m8_t merge,const float* base,vuint8m2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f32m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m1_t test___riscv_vluxei8_v_f64m1_tumu(vbool64_t mask,vfloat64m1_t merge,const double* base,vuint8mf8_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m1_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m2_t test___riscv_vluxei8_v_f64m2_tumu(vbool32_t mask,vfloat64m2_t merge,const double* base,vuint8mf4_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m2_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m4_t test___riscv_vluxei8_v_f64m4_tumu(vbool16_t mask,vfloat64m4_t merge,const double* base,vuint8mf2_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m4_tumu(mask,merge,base,bindex,32);
+}
+
+
+vfloat64m8_t test___riscv_vluxei8_v_f64m8_tumu(vbool8_t mask,vfloat64m8_t merge,const double* base,vuint8m1_t bindex,size_t vl)
+{
+    return __riscv_vluxei8_v_f64m8_tumu(mask,merge,base,bindex,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*tu,\s*mu\s+vluxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vlxei-vsxei-constraint-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vlxei-vsxei-constraint-1.c
new file mode 100644
index 0000000..56e5993
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vlxei-vsxei-constraint-1.c
@@ -0,0 +1,121 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
+
+#include "riscv_vector.h"
+
+/*
+** f1:
+** 	vsetivli\s+zero,4,e32,mf2,tu,m[au]
+** 	vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*zero
+** 	vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*zero
+** 	vluxei8\.v\s+v[0-9]+,\s*\([a-x0-9]+\),\s*v[0-9]+
+** 	vsoxei8\.v\s+v[0-9]+,\s*\([a-x0-9]+\),\s*v[0-9]+
+** 	ret
+*/
+void f1 (void * in, void * in2, void *out)
+{
+  vfloat32mf2_t v = __riscv_vlse32_v_f32mf2 (in, 0, 4);
+  vuint8mf8_t index = __riscv_vlse8_v_u8mf8 (in2, 0, 4);
+  vfloat32mf2_t v2 = __riscv_vluxei8_v_f32mf2_tu (v, in, index, 4);
+  __riscv_vsoxei8_v_f32mf2 (out, index, v2, 4);
+}
+
+/*
+** f2:
+** 	vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]
+** 	vlm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)
+** 	vsetivli\s+zero,4,e32,mf2,\s*t[au],\s*m[au]
+** 	vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*zero
+** 	vluxei8\.v\s+v[0-9]+,\s*\([a-x0-9]+\),\s*v[0-9]+,v0.t
+** 	vsoxei8\.v\s+v[0-9]+,\s*\([a-x0-9]+\),\s*v[0-9]+
+** 	ret
+*/
+void f2 (void * in, void * in2, void *out)
+{
+  vbool64_t mask = *(vbool64_t*)in;
+  asm volatile ("":::"memory");
+  vfloat32mf2_t v = __riscv_vlse32_v_f32mf2 (in, 0, 4);
+  vuint8mf8_t index = __riscv_vlse8_v_u8mf8 (in2, 0, 4);
+  vfloat32mf2_t v2 = __riscv_vluxei8_v_f32mf2_m (mask, in, index, 4);
+  __riscv_vsoxei8_v_f32mf2 (out, index, v2, 4);
+}
+
+/*
+** f3:
+** 	vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]
+** 	vlm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)
+** 	vsetivli\s+zero,\s*4,\s*e32,\s*mf2,\s*tu,\s*mu
+** 	vlse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*zero
+** 	vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*zero
+** 	vluxei8\.v\s+v[0-9]+,\s*\([a-x0-9]+\),\s*v[0-9]+,v0.t
+** 	vsoxei8\.v\s+v[0-9]+,\s*\([a-x0-9]+\),\s*v[0-9]+
+** 	ret
+*/
+void f3 (void * in, void * in2, void *out)
+{
+  vbool64_t mask = *(vbool64_t*)in;
+  asm volatile ("":::"memory");
+  vfloat32mf2_t v = __riscv_vlse32_v_f32mf2 (in, 0, 4);
+  vuint8mf8_t index = __riscv_vlse8_v_u8mf8 (in2, 0, 4);
+  vfloat32mf2_t v2 = __riscv_vluxei8_v_f32mf2_tumu (mask, v, in, index, 4);
+  __riscv_vsoxei8_v_f32mf2 (out, index, v2, 4);
+}
+
+/*
+** f4:
+** 	vsetivli\s+zero,4,e8,mf8,tu,\s*m[au]
+** 	vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),zero
+** 	vluxei8\.v\s+v[0-9]+,\s*\([a-x0-9]+\),\s*v[0-9]+
+** 	vluxei8\.v\s+v[0-9]+,\s*\([a-x0-9]+\),\s*v[0-9]+
+** 	vsoxei8\.v\s+v[0-9]+,\s*\([a-x0-9]+\),\s*v[0-9]+
+** 	ret
+*/
+void f4 (void * in, void * in2, void *out)
+{
+  vuint8mf8_t index = __riscv_vlse8_v_u8mf8 (in2, 0, 4);
+  vint8mf8_t v = __riscv_vluxei8_v_i8mf8 (in, index, 4);
+  vint8mf8_t v2 = __riscv_vluxei8_v_i8mf8_tu (v, in, index, 4);
+  __riscv_vsoxei8_v_i8mf8 (out, index, v2, 4);
+}
+
+/*
+** f5:
+** 	vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]
+** 	vlm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)
+** 	vsetivli\s+zero,4,e8,mf8,t[au],m[au]
+** 	vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),zero
+** 	vluxei8\.v\s+v[0-9]+,\s*\([a-x0-9]+\),\s*v[0-9]+,v0.t
+** 	vsoxei8\.v\s+v[0-9]+,\s*\([a-x0-9]+\),\s*v[0-9]+
+** 	ret
+*/
+void f5 (void * in, void * in2, void *out)
+{
+  vbool64_t mask = *(vbool64_t*)in;
+  asm volatile ("":::"memory");
+  vuint8mf8_t index = __riscv_vlse8_v_u8mf8 (in2, 0, 4);
+  vint8mf8_t v = __riscv_vluxei8_v_i8mf8 (in, index, 4);
+  vint8mf8_t v2 = __riscv_vluxei8_v_i8mf8_m (mask, in, index, 4);
+  __riscv_vsoxei8_v_i8mf8 (out, index, v2, 4);
+}
+
+/*
+** f6:
+** 	vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]
+** 	vlm\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)
+** 	vsetivli\s+zero,4,e8,mf8,tu,mu
+** 	vlse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),zero
+** 	vluxei8\.v\s+v[0-9]+,\s*\([a-x0-9]+\),\s*v[0-9]+
+** 	vluxei8\.v\s+v[0-9]+,\s*\([a-x0-9]+\),\s*v[0-9]+,v0.t
+** 	vsoxei8\.v\s+v[0-9]+,\s*\([a-x0-9]+\),\s*v[0-9]+
+** 	ret
+*/
+void f6 (void * in, void * in2, void *out)
+{
+  vbool64_t mask = *(vbool64_t*)in;
+  asm volatile ("":::"memory");
+  vuint8mf8_t index = __riscv_vlse8_v_u8mf8 (in2, 0, 4);
+  vint8mf8_t v = __riscv_vluxei8_v_i8mf8 (in, index, 4);
+  vint8mf8_t v2 = __riscv_vluxei8_v_i8mf8_tumu (mask, v, in, index, 4);
+  __riscv_vsoxei8_v_i8mf8 (out, index, v2, 4);
+}
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vse-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vse-1.c
new file mode 100644
index 0000000..c08e1e1
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vse-1.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void
+test___riscv_vse8_v_i8mf8(int8_t* base,vint8mf8_t value,size_t vl)
+{
+  __riscv_vse8_v_i8mf8(base,value,vl);
+}
+
+void
+test___riscv_vse8_v_i8mf4(int8_t* base,vint8mf4_t value,size_t vl)
+{
+  __riscv_vse8_v_i8mf4(base,value,vl);
+}
+
+void
+test___riscv_vse8_v_i8mf2(int8_t* base,vint8mf2_t value,size_t vl)
+{
+  __riscv_vse8_v_i8mf2(base,value,vl);
+}
+
+void
+test___riscv_vse8_v_i8m1(int8_t* base,vint8m1_t value,size_t vl)
+{
+  __riscv_vse8_v_i8m1(base,value,vl);
+}
+
+void
+test___riscv_vse8_v_i8m2(int8_t* base,vint8m2_t value,size_t vl)
+{
+  __riscv_vse8_v_i8m2(base,value,vl);
+}
+
+void
+test___riscv_vse8_v_i8m4(int8_t* base,vint8m4_t value,size_t vl)
+{
+  __riscv_vse8_v_i8m4(base,value,vl);
+}
+
+void
+test___riscv_vse8_v_i8m8(int8_t* base,vint8m8_t value,size_t vl)
+{
+  __riscv_vse8_v_i8m8(base,value,vl);
+}
+
+void
+test___riscv_vse8_v_u8mf8(uint8_t* base,vuint8mf8_t value,size_t vl)
+{
+  __riscv_vse8_v_u8mf8(base,value,vl);
+}
+
+void
+test___riscv_vse8_v_u8mf4(uint8_t* base,vuint8mf4_t value,size_t vl)
+{
+  __riscv_vse8_v_u8mf4(base,value,vl);
+}
+
+void
+test___riscv_vse8_v_u8mf2(uint8_t* base,vuint8mf2_t value,size_t vl)
+{
+  __riscv_vse8_v_u8mf2(base,value,vl);
+}
+
+void
+test___riscv_vse8_v_u8m1(uint8_t* base,vuint8m1_t value,size_t vl)
+{
+  __riscv_vse8_v_u8m1(base,value,vl);
+}
+
+void
+test___riscv_vse8_v_u8m2(uint8_t* base,vuint8m2_t value,size_t vl)
+{
+  __riscv_vse8_v_u8m2(base,value,vl);
+}
+
+void
+test___riscv_vse8_v_u8m4(uint8_t* base,vuint8m4_t value,size_t vl)
+{
+  __riscv_vse8_v_u8m4(base,value,vl);
+}
+
+void
+test___riscv_vse8_v_u8m8(uint8_t* base,vuint8m8_t value,size_t vl)
+{
+  __riscv_vse8_v_u8m8(base,value,vl);
+}
+
+void
+test___riscv_vse16_v_i16mf4(int16_t* base,vint16mf4_t value,size_t vl)
+{
+  __riscv_vse16_v_i16mf4(base,value,vl);
+}
+
+void
+test___riscv_vse16_v_i16mf2(int16_t* base,vint16mf2_t value,size_t vl)
+{
+  __riscv_vse16_v_i16mf2(base,value,vl);
+}
+
+void
+test___riscv_vse16_v_i16m1(int16_t* base,vint16m1_t value,size_t vl)
+{
+  __riscv_vse16_v_i16m1(base,value,vl);
+}
+
+void
+test___riscv_vse16_v_i16m2(int16_t* base,vint16m2_t value,size_t vl)
+{
+  __riscv_vse16_v_i16m2(base,value,vl);
+}
+
+void
+test___riscv_vse16_v_i16m4(int16_t* base,vint16m4_t value,size_t vl)
+{
+  __riscv_vse16_v_i16m4(base,value,vl);
+}
+
+void
+test___riscv_vse16_v_i16m8(int16_t* base,vint16m8_t value,size_t vl)
+{
+  __riscv_vse16_v_i16m8(base,value,vl);
+}
+
+void
+test___riscv_vse16_v_u16mf4(uint16_t* base,vuint16mf4_t value,size_t vl)
+{
+  __riscv_vse16_v_u16mf4(base,value,vl);
+}
+
+void
+test___riscv_vse16_v_u16mf2(uint16_t* base,vuint16mf2_t value,size_t vl)
+{
+  __riscv_vse16_v_u16mf2(base,value,vl);
+}
+
+void
+test___riscv_vse16_v_u16m1(uint16_t* base,vuint16m1_t value,size_t vl)
+{
+  __riscv_vse16_v_u16m1(base,value,vl);
+}
+
+void
+test___riscv_vse16_v_u16m2(uint16_t* base,vuint16m2_t value,size_t vl)
+{
+  __riscv_vse16_v_u16m2(base,value,vl);
+}
+
+void
+test___riscv_vse16_v_u16m4(uint16_t* base,vuint16m4_t value,size_t vl)
+{
+  __riscv_vse16_v_u16m4(base,value,vl);
+}
+
+void
+test___riscv_vse16_v_u16m8(uint16_t* base,vuint16m8_t value,size_t vl)
+{
+  __riscv_vse16_v_u16m8(base,value,vl);
+}
+
+void
+test___riscv_vse32_v_i32mf2(int32_t* base,vint32mf2_t value,size_t vl)
+{
+  __riscv_vse32_v_i32mf2(base,value,vl);
+}
+
+void
+test___riscv_vse32_v_i32m1(int32_t* base,vint32m1_t value,size_t vl)
+{
+  __riscv_vse32_v_i32m1(base,value,vl);
+}
+
+void
+test___riscv_vse32_v_i32m2(int32_t* base,vint32m2_t value,size_t vl)
+{
+  __riscv_vse32_v_i32m2(base,value,vl);
+}
+
+void
+test___riscv_vse32_v_i32m4(int32_t* base,vint32m4_t value,size_t vl)
+{
+  __riscv_vse32_v_i32m4(base,value,vl);
+}
+
+void
+test___riscv_vse32_v_i32m8(int32_t* base,vint32m8_t value,size_t vl)
+{
+  __riscv_vse32_v_i32m8(base,value,vl);
+}
+
+void
+test___riscv_vse32_v_u32mf2(uint32_t* base,vuint32mf2_t value,size_t vl)
+{
+  __riscv_vse32_v_u32mf2(base,value,vl);
+}
+
+void
+test___riscv_vse32_v_u32m1(uint32_t* base,vuint32m1_t value,size_t vl)
+{
+  __riscv_vse32_v_u32m1(base,value,vl);
+}
+
+void
+test___riscv_vse32_v_u32m2(uint32_t* base,vuint32m2_t value,size_t vl)
+{
+  __riscv_vse32_v_u32m2(base,value,vl);
+}
+
+void
+test___riscv_vse32_v_u32m4(uint32_t* base,vuint32m4_t value,size_t vl)
+{
+  __riscv_vse32_v_u32m4(base,value,vl);
+}
+
+void
+test___riscv_vse32_v_u32m8(uint32_t* base,vuint32m8_t value,size_t vl)
+{
+  __riscv_vse32_v_u32m8(base,value,vl);
+}
+
+void
+test___riscv_vse32_v_f32mf2(float* base,vfloat32mf2_t value,size_t vl)
+{
+  __riscv_vse32_v_f32mf2(base,value,vl);
+}
+
+void
+test___riscv_vse32_v_f32m1(float* base,vfloat32m1_t value,size_t vl)
+{
+  __riscv_vse32_v_f32m1(base,value,vl);
+}
+
+void
+test___riscv_vse32_v_f32m2(float* base,vfloat32m2_t value,size_t vl)
+{
+  __riscv_vse32_v_f32m2(base,value,vl);
+}
+
+void
+test___riscv_vse32_v_f32m4(float* base,vfloat32m4_t value,size_t vl)
+{
+  __riscv_vse32_v_f32m4(base,value,vl);
+}
+
+void
+test___riscv_vse32_v_f32m8(float* base,vfloat32m8_t value,size_t vl)
+{
+  __riscv_vse32_v_f32m8(base,value,vl);
+}
+
+void
+test___riscv_vse64_v_i64m1(int64_t* base,vint64m1_t value,size_t vl)
+{
+  __riscv_vse64_v_i64m1(base,value,vl);
+}
+
+void
+test___riscv_vse64_v_i64m2(int64_t* base,vint64m2_t value,size_t vl)
+{
+  __riscv_vse64_v_i64m2(base,value,vl);
+}
+
+void
+test___riscv_vse64_v_i64m4(int64_t* base,vint64m4_t value,size_t vl)
+{
+  __riscv_vse64_v_i64m4(base,value,vl);
+}
+
+void
+test___riscv_vse64_v_i64m8(int64_t* base,vint64m8_t value,size_t vl)
+{
+  __riscv_vse64_v_i64m8(base,value,vl);
+}
+
+void
+test___riscv_vse64_v_u64m1(uint64_t* base,vuint64m1_t value,size_t vl)
+{
+  __riscv_vse64_v_u64m1(base,value,vl);
+}
+
+void
+test___riscv_vse64_v_u64m2(uint64_t* base,vuint64m2_t value,size_t vl)
+{
+  __riscv_vse64_v_u64m2(base,value,vl);
+}
+
+void
+test___riscv_vse64_v_u64m4(uint64_t* base,vuint64m4_t value,size_t vl)
+{
+  __riscv_vse64_v_u64m4(base,value,vl);
+}
+
+void
+test___riscv_vse64_v_u64m8(uint64_t* base,vuint64m8_t value,size_t vl)
+{
+  __riscv_vse64_v_u64m8(base,value,vl);
+}
+
+void
+test___riscv_vse64_v_f64m1(double* base,vfloat64m1_t value,size_t vl)
+{
+  __riscv_vse64_v_f64m1(base,value,vl);
+}
+
+void
+test___riscv_vse64_v_f64m2(double* base,vfloat64m2_t value,size_t vl)
+{
+  __riscv_vse64_v_f64m2(base,value,vl);
+}
+
+void
+test___riscv_vse64_v_f64m4(double* base,vfloat64m4_t value,size_t vl)
+{
+  __riscv_vse64_v_f64m4(base,value,vl);
+}
+
+void
+test___riscv_vse64_v_f64m8(double* base,vfloat64m8_t value,size_t vl)
+{
+  __riscv_vse64_v_f64m8(base,value,vl);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vse-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vse-2.c
new file mode 100644
index 0000000..62935c5
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vse-2.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void
+test___riscv_vse8_v_i8mf8(int8_t* base,vint8mf8_t value,size_t vl)
+{
+  __riscv_vse8_v_i8mf8(base,value,31);
+}
+
+void
+test___riscv_vse8_v_i8mf4(int8_t* base,vint8mf4_t value,size_t vl)
+{
+  __riscv_vse8_v_i8mf4(base,value,31);
+}
+
+void
+test___riscv_vse8_v_i8mf2(int8_t* base,vint8mf2_t value,size_t vl)
+{
+  __riscv_vse8_v_i8mf2(base,value,31);
+}
+
+void
+test___riscv_vse8_v_i8m1(int8_t* base,vint8m1_t value,size_t vl)
+{
+  __riscv_vse8_v_i8m1(base,value,31);
+}
+
+void
+test___riscv_vse8_v_i8m2(int8_t* base,vint8m2_t value,size_t vl)
+{
+  __riscv_vse8_v_i8m2(base,value,31);
+}
+
+void
+test___riscv_vse8_v_i8m4(int8_t* base,vint8m4_t value,size_t vl)
+{
+  __riscv_vse8_v_i8m4(base,value,31);
+}
+
+void
+test___riscv_vse8_v_i8m8(int8_t* base,vint8m8_t value,size_t vl)
+{
+  __riscv_vse8_v_i8m8(base,value,31);
+}
+
+void
+test___riscv_vse8_v_u8mf8(uint8_t* base,vuint8mf8_t value,size_t vl)
+{
+  __riscv_vse8_v_u8mf8(base,value,31);
+}
+
+void
+test___riscv_vse8_v_u8mf4(uint8_t* base,vuint8mf4_t value,size_t vl)
+{
+  __riscv_vse8_v_u8mf4(base,value,31);
+}
+
+void
+test___riscv_vse8_v_u8mf2(uint8_t* base,vuint8mf2_t value,size_t vl)
+{
+  __riscv_vse8_v_u8mf2(base,value,31);
+}
+
+void
+test___riscv_vse8_v_u8m1(uint8_t* base,vuint8m1_t value,size_t vl)
+{
+  __riscv_vse8_v_u8m1(base,value,31);
+}
+
+void
+test___riscv_vse8_v_u8m2(uint8_t* base,vuint8m2_t value,size_t vl)
+{
+  __riscv_vse8_v_u8m2(base,value,31);
+}
+
+void
+test___riscv_vse8_v_u8m4(uint8_t* base,vuint8m4_t value,size_t vl)
+{
+  __riscv_vse8_v_u8m4(base,value,31);
+}
+
+void
+test___riscv_vse8_v_u8m8(uint8_t* base,vuint8m8_t value,size_t vl)
+{
+  __riscv_vse8_v_u8m8(base,value,31);
+}
+
+void
+test___riscv_vse16_v_i16mf4(int16_t* base,vint16mf4_t value,size_t vl)
+{
+  __riscv_vse16_v_i16mf4(base,value,31);
+}
+
+void
+test___riscv_vse16_v_i16mf2(int16_t* base,vint16mf2_t value,size_t vl)
+{
+  __riscv_vse16_v_i16mf2(base,value,31);
+}
+
+void
+test___riscv_vse16_v_i16m1(int16_t* base,vint16m1_t value,size_t vl)
+{
+  __riscv_vse16_v_i16m1(base,value,31);
+}
+
+void
+test___riscv_vse16_v_i16m2(int16_t* base,vint16m2_t value,size_t vl)
+{
+  __riscv_vse16_v_i16m2(base,value,31);
+}
+
+void
+test___riscv_vse16_v_i16m4(int16_t* base,vint16m4_t value,size_t vl)
+{
+  __riscv_vse16_v_i16m4(base,value,31);
+}
+
+void
+test___riscv_vse16_v_i16m8(int16_t* base,vint16m8_t value,size_t vl)
+{
+  __riscv_vse16_v_i16m8(base,value,31);
+}
+
+void
+test___riscv_vse16_v_u16mf4(uint16_t* base,vuint16mf4_t value,size_t vl)
+{
+  __riscv_vse16_v_u16mf4(base,value,31);
+}
+
+void
+test___riscv_vse16_v_u16mf2(uint16_t* base,vuint16mf2_t value,size_t vl)
+{
+  __riscv_vse16_v_u16mf2(base,value,31);
+}
+
+void
+test___riscv_vse16_v_u16m1(uint16_t* base,vuint16m1_t value,size_t vl)
+{
+  __riscv_vse16_v_u16m1(base,value,31);
+}
+
+void
+test___riscv_vse16_v_u16m2(uint16_t* base,vuint16m2_t value,size_t vl)
+{
+  __riscv_vse16_v_u16m2(base,value,31);
+}
+
+void
+test___riscv_vse16_v_u16m4(uint16_t* base,vuint16m4_t value,size_t vl)
+{
+  __riscv_vse16_v_u16m4(base,value,31);
+}
+
+void
+test___riscv_vse16_v_u16m8(uint16_t* base,vuint16m8_t value,size_t vl)
+{
+  __riscv_vse16_v_u16m8(base,value,31);
+}
+
+void
+test___riscv_vse32_v_i32mf2(int32_t* base,vint32mf2_t value,size_t vl)
+{
+  __riscv_vse32_v_i32mf2(base,value,31);
+}
+
+void
+test___riscv_vse32_v_i32m1(int32_t* base,vint32m1_t value,size_t vl)
+{
+  __riscv_vse32_v_i32m1(base,value,31);
+}
+
+void
+test___riscv_vse32_v_i32m2(int32_t* base,vint32m2_t value,size_t vl)
+{
+  __riscv_vse32_v_i32m2(base,value,31);
+}
+
+void
+test___riscv_vse32_v_i32m4(int32_t* base,vint32m4_t value,size_t vl)
+{
+  __riscv_vse32_v_i32m4(base,value,31);
+}
+
+void
+test___riscv_vse32_v_i32m8(int32_t* base,vint32m8_t value,size_t vl)
+{
+  __riscv_vse32_v_i32m8(base,value,31);
+}
+
+void
+test___riscv_vse32_v_u32mf2(uint32_t* base,vuint32mf2_t value,size_t vl)
+{
+  __riscv_vse32_v_u32mf2(base,value,31);
+}
+
+void
+test___riscv_vse32_v_u32m1(uint32_t* base,vuint32m1_t value,size_t vl)
+{
+  __riscv_vse32_v_u32m1(base,value,31);
+}
+
+void
+test___riscv_vse32_v_u32m2(uint32_t* base,vuint32m2_t value,size_t vl)
+{
+  __riscv_vse32_v_u32m2(base,value,31);
+}
+
+void
+test___riscv_vse32_v_u32m4(uint32_t* base,vuint32m4_t value,size_t vl)
+{
+  __riscv_vse32_v_u32m4(base,value,31);
+}
+
+void
+test___riscv_vse32_v_u32m8(uint32_t* base,vuint32m8_t value,size_t vl)
+{
+  __riscv_vse32_v_u32m8(base,value,31);
+}
+
+void
+test___riscv_vse32_v_f32mf2(float* base,vfloat32mf2_t value,size_t vl)
+{
+  __riscv_vse32_v_f32mf2(base,value,31);
+}
+
+void
+test___riscv_vse32_v_f32m1(float* base,vfloat32m1_t value,size_t vl)
+{
+  __riscv_vse32_v_f32m1(base,value,31);
+}
+
+void
+test___riscv_vse32_v_f32m2(float* base,vfloat32m2_t value,size_t vl)
+{
+  __riscv_vse32_v_f32m2(base,value,31);
+}
+
+void
+test___riscv_vse32_v_f32m4(float* base,vfloat32m4_t value,size_t vl)
+{
+  __riscv_vse32_v_f32m4(base,value,31);
+}
+
+void
+test___riscv_vse32_v_f32m8(float* base,vfloat32m8_t value,size_t vl)
+{
+  __riscv_vse32_v_f32m8(base,value,31);
+}
+
+void
+test___riscv_vse64_v_i64m1(int64_t* base,vint64m1_t value,size_t vl)
+{
+  __riscv_vse64_v_i64m1(base,value,31);
+}
+
+void
+test___riscv_vse64_v_i64m2(int64_t* base,vint64m2_t value,size_t vl)
+{
+  __riscv_vse64_v_i64m2(base,value,31);
+}
+
+void
+test___riscv_vse64_v_i64m4(int64_t* base,vint64m4_t value,size_t vl)
+{
+  __riscv_vse64_v_i64m4(base,value,31);
+}
+
+void
+test___riscv_vse64_v_i64m8(int64_t* base,vint64m8_t value,size_t vl)
+{
+  __riscv_vse64_v_i64m8(base,value,31);
+}
+
+void
+test___riscv_vse64_v_u64m1(uint64_t* base,vuint64m1_t value,size_t vl)
+{
+  __riscv_vse64_v_u64m1(base,value,31);
+}
+
+void
+test___riscv_vse64_v_u64m2(uint64_t* base,vuint64m2_t value,size_t vl)
+{
+  __riscv_vse64_v_u64m2(base,value,31);
+}
+
+void
+test___riscv_vse64_v_u64m4(uint64_t* base,vuint64m4_t value,size_t vl)
+{
+  __riscv_vse64_v_u64m4(base,value,31);
+}
+
+void
+test___riscv_vse64_v_u64m8(uint64_t* base,vuint64m8_t value,size_t vl)
+{
+  __riscv_vse64_v_u64m8(base,value,31);
+}
+
+void
+test___riscv_vse64_v_f64m1(double* base,vfloat64m1_t value,size_t vl)
+{
+  __riscv_vse64_v_f64m1(base,value,31);
+}
+
+void
+test___riscv_vse64_v_f64m2(double* base,vfloat64m2_t value,size_t vl)
+{
+  __riscv_vse64_v_f64m2(base,value,31);
+}
+
+void
+test___riscv_vse64_v_f64m4(double* base,vfloat64m4_t value,size_t vl)
+{
+  __riscv_vse64_v_f64m4(base,value,31);
+}
+
+void
+test___riscv_vse64_v_f64m8(double* base,vfloat64m8_t value,size_t vl)
+{
+  __riscv_vse64_v_f64m8(base,value,31);
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vse-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vse-3.c
new file mode 100644
index 0000000..c06931b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vse-3.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void
+test___riscv_vse8_v_i8mf8(int8_t* base,vint8mf8_t value,size_t vl)
+{
+  __riscv_vse8_v_i8mf8(base,value,32);
+}
+
+void
+test___riscv_vse8_v_i8mf4(int8_t* base,vint8mf4_t value,size_t vl)
+{
+  __riscv_vse8_v_i8mf4(base,value,32);
+}
+
+void
+test___riscv_vse8_v_i8mf2(int8_t* base,vint8mf2_t value,size_t vl)
+{
+  __riscv_vse8_v_i8mf2(base,value,32);
+}
+
+void
+test___riscv_vse8_v_i8m1(int8_t* base,vint8m1_t value,size_t vl)
+{
+  __riscv_vse8_v_i8m1(base,value,32);
+}
+
+void
+test___riscv_vse8_v_i8m2(int8_t* base,vint8m2_t value,size_t vl)
+{
+  __riscv_vse8_v_i8m2(base,value,32);
+}
+
+void
+test___riscv_vse8_v_i8m4(int8_t* base,vint8m4_t value,size_t vl)
+{
+  __riscv_vse8_v_i8m4(base,value,32);
+}
+
+void
+test___riscv_vse8_v_i8m8(int8_t* base,vint8m8_t value,size_t vl)
+{
+  __riscv_vse8_v_i8m8(base,value,32);
+}
+
+void
+test___riscv_vse8_v_u8mf8(uint8_t* base,vuint8mf8_t value,size_t vl)
+{
+  __riscv_vse8_v_u8mf8(base,value,32);
+}
+
+void
+test___riscv_vse8_v_u8mf4(uint8_t* base,vuint8mf4_t value,size_t vl)
+{
+  __riscv_vse8_v_u8mf4(base,value,32);
+}
+
+void
+test___riscv_vse8_v_u8mf2(uint8_t* base,vuint8mf2_t value,size_t vl)
+{
+  __riscv_vse8_v_u8mf2(base,value,32);
+}
+
+void
+test___riscv_vse8_v_u8m1(uint8_t* base,vuint8m1_t value,size_t vl)
+{
+  __riscv_vse8_v_u8m1(base,value,32);
+}
+
+void
+test___riscv_vse8_v_u8m2(uint8_t* base,vuint8m2_t value,size_t vl)
+{
+  __riscv_vse8_v_u8m2(base,value,32);
+}
+
+void
+test___riscv_vse8_v_u8m4(uint8_t* base,vuint8m4_t value,size_t vl)
+{
+  __riscv_vse8_v_u8m4(base,value,32);
+}
+
+void
+test___riscv_vse8_v_u8m8(uint8_t* base,vuint8m8_t value,size_t vl)
+{
+  __riscv_vse8_v_u8m8(base,value,32);
+}
+
+void
+test___riscv_vse16_v_i16mf4(int16_t* base,vint16mf4_t value,size_t vl)
+{
+  __riscv_vse16_v_i16mf4(base,value,32);
+}
+
+void
+test___riscv_vse16_v_i16mf2(int16_t* base,vint16mf2_t value,size_t vl)
+{
+  __riscv_vse16_v_i16mf2(base,value,32);
+}
+
+void
+test___riscv_vse16_v_i16m1(int16_t* base,vint16m1_t value,size_t vl)
+{
+  __riscv_vse16_v_i16m1(base,value,32);
+}
+
+void
+test___riscv_vse16_v_i16m2(int16_t* base,vint16m2_t value,size_t vl)
+{
+  __riscv_vse16_v_i16m2(base,value,32);
+}
+
+void
+test___riscv_vse16_v_i16m4(int16_t* base,vint16m4_t value,size_t vl)
+{
+  __riscv_vse16_v_i16m4(base,value,32);
+}
+
+void
+test___riscv_vse16_v_i16m8(int16_t* base,vint16m8_t value,size_t vl)
+{
+  __riscv_vse16_v_i16m8(base,value,32);
+}
+
+void
+test___riscv_vse16_v_u16mf4(uint16_t* base,vuint16mf4_t value,size_t vl)
+{
+  __riscv_vse16_v_u16mf4(base,value,32);
+}
+
+void
+test___riscv_vse16_v_u16mf2(uint16_t* base,vuint16mf2_t value,size_t vl)
+{
+  __riscv_vse16_v_u16mf2(base,value,32);
+}
+
+void
+test___riscv_vse16_v_u16m1(uint16_t* base,vuint16m1_t value,size_t vl)
+{
+  __riscv_vse16_v_u16m1(base,value,32);
+}
+
+void
+test___riscv_vse16_v_u16m2(uint16_t* base,vuint16m2_t value,size_t vl)
+{
+  __riscv_vse16_v_u16m2(base,value,32);
+}
+
+void
+test___riscv_vse16_v_u16m4(uint16_t* base,vuint16m4_t value,size_t vl)
+{
+  __riscv_vse16_v_u16m4(base,value,32);
+}
+
+void
+test___riscv_vse16_v_u16m8(uint16_t* base,vuint16m8_t value,size_t vl)
+{
+  __riscv_vse16_v_u16m8(base,value,32);
+}
+
+void
+test___riscv_vse32_v_i32mf2(int32_t* base,vint32mf2_t value,size_t vl)
+{
+  __riscv_vse32_v_i32mf2(base,value,32);
+}
+
+void
+test___riscv_vse32_v_i32m1(int32_t* base,vint32m1_t value,size_t vl)
+{
+  __riscv_vse32_v_i32m1(base,value,32);
+}
+
+void
+test___riscv_vse32_v_i32m2(int32_t* base,vint32m2_t value,size_t vl)
+{
+  __riscv_vse32_v_i32m2(base,value,32);
+}
+
+void
+test___riscv_vse32_v_i32m4(int32_t* base,vint32m4_t value,size_t vl)
+{
+  __riscv_vse32_v_i32m4(base,value,32);
+}
+
+void
+test___riscv_vse32_v_i32m8(int32_t* base,vint32m8_t value,size_t vl)
+{
+  __riscv_vse32_v_i32m8(base,value,32);
+}
+
+void
+test___riscv_vse32_v_u32mf2(uint32_t* base,vuint32mf2_t value,size_t vl)
+{
+  __riscv_vse32_v_u32mf2(base,value,32);
+}
+
+void
+test___riscv_vse32_v_u32m1(uint32_t* base,vuint32m1_t value,size_t vl)
+{
+  __riscv_vse32_v_u32m1(base,value,32);
+}
+
+void
+test___riscv_vse32_v_u32m2(uint32_t* base,vuint32m2_t value,size_t vl)
+{
+  __riscv_vse32_v_u32m2(base,value,32);
+}
+
+void
+test___riscv_vse32_v_u32m4(uint32_t* base,vuint32m4_t value,size_t vl)
+{
+  __riscv_vse32_v_u32m4(base,value,32);
+}
+
+void
+test___riscv_vse32_v_u32m8(uint32_t* base,vuint32m8_t value,size_t vl)
+{
+  __riscv_vse32_v_u32m8(base,value,32);
+}
+
+void
+test___riscv_vse32_v_f32mf2(float* base,vfloat32mf2_t value,size_t vl)
+{
+  __riscv_vse32_v_f32mf2(base,value,32);
+}
+
+void
+test___riscv_vse32_v_f32m1(float* base,vfloat32m1_t value,size_t vl)
+{
+  __riscv_vse32_v_f32m1(base,value,32);
+}
+
+void
+test___riscv_vse32_v_f32m2(float* base,vfloat32m2_t value,size_t vl)
+{
+  __riscv_vse32_v_f32m2(base,value,32);
+}
+
+void
+test___riscv_vse32_v_f32m4(float* base,vfloat32m4_t value,size_t vl)
+{
+  __riscv_vse32_v_f32m4(base,value,32);
+}
+
+void
+test___riscv_vse32_v_f32m8(float* base,vfloat32m8_t value,size_t vl)
+{
+  __riscv_vse32_v_f32m8(base,value,32);
+}
+
+void
+test___riscv_vse64_v_i64m1(int64_t* base,vint64m1_t value,size_t vl)
+{
+  __riscv_vse64_v_i64m1(base,value,32);
+}
+
+void
+test___riscv_vse64_v_i64m2(int64_t* base,vint64m2_t value,size_t vl)
+{
+  __riscv_vse64_v_i64m2(base,value,32);
+}
+
+void
+test___riscv_vse64_v_i64m4(int64_t* base,vint64m4_t value,size_t vl)
+{
+  __riscv_vse64_v_i64m4(base,value,32);
+}
+
+void
+test___riscv_vse64_v_i64m8(int64_t* base,vint64m8_t value,size_t vl)
+{
+  __riscv_vse64_v_i64m8(base,value,32);
+}
+
+void
+test___riscv_vse64_v_u64m1(uint64_t* base,vuint64m1_t value,size_t vl)
+{
+  __riscv_vse64_v_u64m1(base,value,32);
+}
+
+void
+test___riscv_vse64_v_u64m2(uint64_t* base,vuint64m2_t value,size_t vl)
+{
+  __riscv_vse64_v_u64m2(base,value,32);
+}
+
+void
+test___riscv_vse64_v_u64m4(uint64_t* base,vuint64m4_t value,size_t vl)
+{
+  __riscv_vse64_v_u64m4(base,value,32);
+}
+
+void
+test___riscv_vse64_v_u64m8(uint64_t* base,vuint64m8_t value,size_t vl)
+{
+  __riscv_vse64_v_u64m8(base,value,32);
+}
+
+void
+test___riscv_vse64_v_f64m1(double* base,vfloat64m1_t value,size_t vl)
+{
+  __riscv_vse64_v_f64m1(base,value,32);
+}
+
+void
+test___riscv_vse64_v_f64m2(double* base,vfloat64m2_t value,size_t vl)
+{
+  __riscv_vse64_v_f64m2(base,value,32);
+}
+
+void
+test___riscv_vse64_v_f64m4(double* base,vfloat64m4_t value,size_t vl)
+{
+  __riscv_vse64_v_f64m4(base,value,32);
+}
+
+void
+test___riscv_vse64_v_f64m8(double* base,vfloat64m8_t value,size_t vl)
+{
+  __riscv_vse64_v_f64m8(base,value,32);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\)} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vse-constraint-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vse-constraint-1.c
new file mode 100644
index 0000000..5b8b9b4
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vse-constraint-1.c
@@ -0,0 +1,97 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3" } */
+
+#include "riscv_vector.h"
+
+void f (int * restrict in, int * restrict out, void * restrict mask_in, int n)
+{
+  vfloat32mf2_t v = __riscv_vle32_v_f32mf2 ((float *)(in + 10000), 19);
+  __riscv_vse32_v_f32mf2 ((float *)(out + 10000), v, 19);
+  vbool64_t mask = *(vbool64_t*)mask_in;
+  for (int i = 0; i < n; i++)
+    {
+      vint16mf2_t v1 = __riscv_vle16_v_i16mf2 ((int16_t *)(in + i + 1), 19);
+      __riscv_vse16_v_i16mf2 ((int16_t *)(out + i + 1), v1, 19);
+
+      vint32mf2_t v2 = __riscv_vle32_v_i32mf2 ((int32_t *)(in + i + 2), 19);
+      __riscv_vse32_v_i32mf2 ((int32_t *)(out + i + 2), v2, 19);
+
+      vint32mf2_t v3 = __riscv_vle32_v_i32mf2_tumu (mask, v2, (int32_t *)(in + i + 200), 13);
+      __riscv_vse32_v_i32mf2 ((int32_t *)(out + i + 200), v3, 13);
+
+      vfloat64m1_t v4 = __riscv_vle64_v_f64m1_m (mask, (double *)(in + i + 300), 11);
+      __riscv_vse64_v_f64m1 ((double *)(out + i + 300), v4, 11);
+
+      vfloat64m1_t v5 = __riscv_vle64_v_f64m1_tum (mask, v4, (double *)(in + i + 500), 11);
+      __riscv_vse64_v_f64m1 ((double *)(out + i + 500), v5, 11);
+
+      vfloat64m1_t v6 = __riscv_vle64_v_f64m1_mu (mask, v5, (double *)(in + i + 600), 11);
+      __riscv_vse64_v_f64m1_m (mask, (double *)(out + i + 600), v6, 11);
+
+      vuint8mf4_t v7 = __riscv_vle8_v_u8mf4 ((uint8_t *)(in + i + 700), 11);
+      __riscv_vse8_v_u8mf4 ((uint8_t *)(out + i + 700), v7, 11);
+    }
+}
+
+void f2 (int * restrict in, int * restrict out, void * restrict mask_in, int n)
+{
+  vfloat32mf2_t v = __riscv_vle32_v_f32mf2 ((float *)(in + 10000), 19);
+  __riscv_vse32_v_f32mf2 ((float *)(out + 10000), v, 19);
+  vbool64_t mask = *(vbool64_t*)mask_in;
+  for (int i = 0; i < n; i++)
+    {
+      vint16mf2_t v1 = __riscv_vle16_v_i16mf2 ((int16_t *)(in + i + 1), 19);
+      __riscv_vse16_v_i16mf2 ((int16_t *)(out + i + 1), v1, 19);
+
+      vint32mf2_t v2 = __riscv_vle32_v_i32mf2 ((int32_t *)(in + i + 2), 19);
+      __riscv_vse32_v_i32mf2 ((int32_t *)(out + i + 2), v2, 19);
+
+      vint32mf2_t v3 = __riscv_vle32_v_i32mf2_tumu (mask, v2, (int32_t *)(in + i + 200), 13);
+      __riscv_vse32_v_i32mf2 ((int32_t *)(out + i + 200), v2, 13);
+
+      vfloat64m1_t v4 = __riscv_vle64_v_f64m1_m (mask, (double *)(in + i + 300), 11);
+      __riscv_vse64_v_f64m1 ((double *)(out + i + 300), v4, 11);
+
+      vfloat64m1_t v5 = __riscv_vle64_v_f64m1_tum (mask, v4, (double *)(in + i + 500), 11);
+      __riscv_vse64_v_f64m1 ((double *)(out + i + 500), v5, 11);
+
+      vfloat64m1_t v6 = __riscv_vle64_v_f64m1_mu (mask, v5, (double *)(in + i + 600), 11);
+      __riscv_vse64_v_f64m1_m (mask, (double *)(out + i + 600), v6, 11);
+
+      vuint8mf4_t v7 = __riscv_vle8_v_u8mf4 ((uint8_t *)(in + i + 700), 11);
+      __riscv_vse8_v_u8mf4 ((uint8_t *)(out + i + 700), v7, 11);
+    }
+}
+
+void f3 (int * restrict in, int * restrict out, void * restrict mask_in, int n)
+{
+  vfloat32mf2_t v = __riscv_vle32_v_f32mf2 ((float *)(in + 10000), 19);
+  __riscv_vse32_v_f32mf2 ((float *)(out + 10000), v, 19);
+  vbool64_t mask = *(vbool64_t*)mask_in;
+  for (int i = 0; i < n; i++)
+    {
+      vint16mf2_t v1 = __riscv_vle16_v_i16mf2 ((int16_t *)(in + i + 1), 19);
+      __riscv_vse16_v_i16mf2 ((int16_t *)(out + i + 1), v1, 19);
+
+      vint32mf2_t v2 = __riscv_vle32_v_i32mf2 ((int32_t *)(in + i + 2), 19);
+      __riscv_vse32_v_i32mf2 ((int32_t *)(out + i + 2), v2, 19);
+
+      vint32mf2_t v3 = __riscv_vle32_v_i32mf2_tumu (mask, v2, (int32_t *)(in + i + 200), 13);
+      *(vint32mf2_t*)(out + i + 200) = v3;
+
+      vfloat64m1_t v4 = __riscv_vle64_v_f64m1_m (mask, (double *)(in + i + 300), 11);
+      __riscv_vse64_v_f64m1 ((double *)(out + i + 300), v4, 11);
+
+      vfloat64m1_t v5 = __riscv_vle64_v_f64m1_tum (mask, v4, (double *)(in + i + 500), 11);
+      __riscv_vse64_v_f64m1 ((double *)(out + i + 500), v5, 11);
+
+      vfloat64m1_t v6 = __riscv_vle64_v_f64m1_mu (mask, v5, (double *)(in + i + 600), 11);
+      __riscv_vse64_v_f64m1_m (mask, (double *)(out + i + 600), v6, 11);
+
+      vuint8mf4_t v7 = __riscv_vle8_v_u8mf4 ((uint8_t *)(in + i + 700), 11);
+      __riscv_vse8_v_u8mf4 ((uint8_t *)(out + i + 700), v7, 11);
+    }
+}
+
+/* It should not have redundant vector register spills which produce csrr vlenb instructions allocate stack.  */
+/* { dg-final { scan-assembler-not {csrr\s+[a-x0-9]+,\s*vlenb} } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vse_m-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vse_m-1.c
new file mode 100644
index 0000000..46a79c0
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vse_m-1.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void
+test___riscv_vse8_v_i8mf8_m(vbool64_t mask,int8_t* base,vint8mf8_t value,size_t vl)
+{
+  __riscv_vse8_v_i8mf8_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse8_v_i8mf4_m(vbool32_t mask,int8_t* base,vint8mf4_t value,size_t vl)
+{
+  __riscv_vse8_v_i8mf4_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse8_v_i8mf2_m(vbool16_t mask,int8_t* base,vint8mf2_t value,size_t vl)
+{
+  __riscv_vse8_v_i8mf2_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse8_v_i8m1_m(vbool8_t mask,int8_t* base,vint8m1_t value,size_t vl)
+{
+  __riscv_vse8_v_i8m1_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse8_v_i8m2_m(vbool4_t mask,int8_t* base,vint8m2_t value,size_t vl)
+{
+  __riscv_vse8_v_i8m2_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse8_v_i8m4_m(vbool2_t mask,int8_t* base,vint8m4_t value,size_t vl)
+{
+  __riscv_vse8_v_i8m4_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse8_v_i8m8_m(vbool1_t mask,int8_t* base,vint8m8_t value,size_t vl)
+{
+  __riscv_vse8_v_i8m8_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse8_v_u8mf8_m(vbool64_t mask,uint8_t* base,vuint8mf8_t value,size_t vl)
+{
+  __riscv_vse8_v_u8mf8_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse8_v_u8mf4_m(vbool32_t mask,uint8_t* base,vuint8mf4_t value,size_t vl)
+{
+  __riscv_vse8_v_u8mf4_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse8_v_u8mf2_m(vbool16_t mask,uint8_t* base,vuint8mf2_t value,size_t vl)
+{
+  __riscv_vse8_v_u8mf2_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse8_v_u8m1_m(vbool8_t mask,uint8_t* base,vuint8m1_t value,size_t vl)
+{
+  __riscv_vse8_v_u8m1_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse8_v_u8m2_m(vbool4_t mask,uint8_t* base,vuint8m2_t value,size_t vl)
+{
+  __riscv_vse8_v_u8m2_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse8_v_u8m4_m(vbool2_t mask,uint8_t* base,vuint8m4_t value,size_t vl)
+{
+  __riscv_vse8_v_u8m4_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse8_v_u8m8_m(vbool1_t mask,uint8_t* base,vuint8m8_t value,size_t vl)
+{
+  __riscv_vse8_v_u8m8_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse16_v_i16mf4_m(vbool64_t mask,int16_t* base,vint16mf4_t value,size_t vl)
+{
+  __riscv_vse16_v_i16mf4_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse16_v_i16mf2_m(vbool32_t mask,int16_t* base,vint16mf2_t value,size_t vl)
+{
+  __riscv_vse16_v_i16mf2_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse16_v_i16m1_m(vbool16_t mask,int16_t* base,vint16m1_t value,size_t vl)
+{
+  __riscv_vse16_v_i16m1_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse16_v_i16m2_m(vbool8_t mask,int16_t* base,vint16m2_t value,size_t vl)
+{
+  __riscv_vse16_v_i16m2_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse16_v_i16m4_m(vbool4_t mask,int16_t* base,vint16m4_t value,size_t vl)
+{
+  __riscv_vse16_v_i16m4_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse16_v_i16m8_m(vbool2_t mask,int16_t* base,vint16m8_t value,size_t vl)
+{
+  __riscv_vse16_v_i16m8_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse16_v_u16mf4_m(vbool64_t mask,uint16_t* base,vuint16mf4_t value,size_t vl)
+{
+  __riscv_vse16_v_u16mf4_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse16_v_u16mf2_m(vbool32_t mask,uint16_t* base,vuint16mf2_t value,size_t vl)
+{
+  __riscv_vse16_v_u16mf2_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse16_v_u16m1_m(vbool16_t mask,uint16_t* base,vuint16m1_t value,size_t vl)
+{
+  __riscv_vse16_v_u16m1_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse16_v_u16m2_m(vbool8_t mask,uint16_t* base,vuint16m2_t value,size_t vl)
+{
+  __riscv_vse16_v_u16m2_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse16_v_u16m4_m(vbool4_t mask,uint16_t* base,vuint16m4_t value,size_t vl)
+{
+  __riscv_vse16_v_u16m4_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse16_v_u16m8_m(vbool2_t mask,uint16_t* base,vuint16m8_t value,size_t vl)
+{
+  __riscv_vse16_v_u16m8_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse32_v_i32mf2_m(vbool64_t mask,int32_t* base,vint32mf2_t value,size_t vl)
+{
+  __riscv_vse32_v_i32mf2_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse32_v_i32m1_m(vbool32_t mask,int32_t* base,vint32m1_t value,size_t vl)
+{
+  __riscv_vse32_v_i32m1_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse32_v_i32m2_m(vbool16_t mask,int32_t* base,vint32m2_t value,size_t vl)
+{
+  __riscv_vse32_v_i32m2_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse32_v_i32m4_m(vbool8_t mask,int32_t* base,vint32m4_t value,size_t vl)
+{
+  __riscv_vse32_v_i32m4_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse32_v_i32m8_m(vbool4_t mask,int32_t* base,vint32m8_t value,size_t vl)
+{
+  __riscv_vse32_v_i32m8_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse32_v_u32mf2_m(vbool64_t mask,uint32_t* base,vuint32mf2_t value,size_t vl)
+{
+  __riscv_vse32_v_u32mf2_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse32_v_u32m1_m(vbool32_t mask,uint32_t* base,vuint32m1_t value,size_t vl)
+{
+  __riscv_vse32_v_u32m1_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse32_v_u32m2_m(vbool16_t mask,uint32_t* base,vuint32m2_t value,size_t vl)
+{
+  __riscv_vse32_v_u32m2_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse32_v_u32m4_m(vbool8_t mask,uint32_t* base,vuint32m4_t value,size_t vl)
+{
+  __riscv_vse32_v_u32m4_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse32_v_u32m8_m(vbool4_t mask,uint32_t* base,vuint32m8_t value,size_t vl)
+{
+  __riscv_vse32_v_u32m8_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse32_v_f32mf2_m(vbool64_t mask,float* base,vfloat32mf2_t value,size_t vl)
+{
+  __riscv_vse32_v_f32mf2_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse32_v_f32m1_m(vbool32_t mask,float* base,vfloat32m1_t value,size_t vl)
+{
+  __riscv_vse32_v_f32m1_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse32_v_f32m2_m(vbool16_t mask,float* base,vfloat32m2_t value,size_t vl)
+{
+  __riscv_vse32_v_f32m2_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse32_v_f32m4_m(vbool8_t mask,float* base,vfloat32m4_t value,size_t vl)
+{
+  __riscv_vse32_v_f32m4_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse32_v_f32m8_m(vbool4_t mask,float* base,vfloat32m8_t value,size_t vl)
+{
+  __riscv_vse32_v_f32m8_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse64_v_i64m1_m(vbool64_t mask,int64_t* base,vint64m1_t value,size_t vl)
+{
+  __riscv_vse64_v_i64m1_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse64_v_i64m2_m(vbool32_t mask,int64_t* base,vint64m2_t value,size_t vl)
+{
+  __riscv_vse64_v_i64m2_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse64_v_i64m4_m(vbool16_t mask,int64_t* base,vint64m4_t value,size_t vl)
+{
+  __riscv_vse64_v_i64m4_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse64_v_i64m8_m(vbool8_t mask,int64_t* base,vint64m8_t value,size_t vl)
+{
+  __riscv_vse64_v_i64m8_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse64_v_u64m1_m(vbool64_t mask,uint64_t* base,vuint64m1_t value,size_t vl)
+{
+  __riscv_vse64_v_u64m1_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse64_v_u64m2_m(vbool32_t mask,uint64_t* base,vuint64m2_t value,size_t vl)
+{
+  __riscv_vse64_v_u64m2_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse64_v_u64m4_m(vbool16_t mask,uint64_t* base,vuint64m4_t value,size_t vl)
+{
+  __riscv_vse64_v_u64m4_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse64_v_u64m8_m(vbool8_t mask,uint64_t* base,vuint64m8_t value,size_t vl)
+{
+  __riscv_vse64_v_u64m8_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse64_v_f64m1_m(vbool64_t mask,double* base,vfloat64m1_t value,size_t vl)
+{
+  __riscv_vse64_v_f64m1_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse64_v_f64m2_m(vbool32_t mask,double* base,vfloat64m2_t value,size_t vl)
+{
+  __riscv_vse64_v_f64m2_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse64_v_f64m4_m(vbool16_t mask,double* base,vfloat64m4_t value,size_t vl)
+{
+  __riscv_vse64_v_f64m4_m(mask,base,value,vl);
+}
+
+void
+test___riscv_vse64_v_f64m8_m(vbool8_t mask,double* base,vfloat64m8_t value,size_t vl)
+{
+  __riscv_vse64_v_f64m8_m(mask,base,value,vl);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vse_m-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vse_m-2.c
new file mode 100644
index 0000000..c1fa00e
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vse_m-2.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void
+test___riscv_vse8_v_i8mf8_m(vbool64_t mask,int8_t* base,vint8mf8_t value,size_t vl)
+{
+  __riscv_vse8_v_i8mf8_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse8_v_i8mf4_m(vbool32_t mask,int8_t* base,vint8mf4_t value,size_t vl)
+{
+  __riscv_vse8_v_i8mf4_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse8_v_i8mf2_m(vbool16_t mask,int8_t* base,vint8mf2_t value,size_t vl)
+{
+  __riscv_vse8_v_i8mf2_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse8_v_i8m1_m(vbool8_t mask,int8_t* base,vint8m1_t value,size_t vl)
+{
+  __riscv_vse8_v_i8m1_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse8_v_i8m2_m(vbool4_t mask,int8_t* base,vint8m2_t value,size_t vl)
+{
+  __riscv_vse8_v_i8m2_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse8_v_i8m4_m(vbool2_t mask,int8_t* base,vint8m4_t value,size_t vl)
+{
+  __riscv_vse8_v_i8m4_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse8_v_i8m8_m(vbool1_t mask,int8_t* base,vint8m8_t value,size_t vl)
+{
+  __riscv_vse8_v_i8m8_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse8_v_u8mf8_m(vbool64_t mask,uint8_t* base,vuint8mf8_t value,size_t vl)
+{
+  __riscv_vse8_v_u8mf8_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse8_v_u8mf4_m(vbool32_t mask,uint8_t* base,vuint8mf4_t value,size_t vl)
+{
+  __riscv_vse8_v_u8mf4_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse8_v_u8mf2_m(vbool16_t mask,uint8_t* base,vuint8mf2_t value,size_t vl)
+{
+  __riscv_vse8_v_u8mf2_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse8_v_u8m1_m(vbool8_t mask,uint8_t* base,vuint8m1_t value,size_t vl)
+{
+  __riscv_vse8_v_u8m1_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse8_v_u8m2_m(vbool4_t mask,uint8_t* base,vuint8m2_t value,size_t vl)
+{
+  __riscv_vse8_v_u8m2_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse8_v_u8m4_m(vbool2_t mask,uint8_t* base,vuint8m4_t value,size_t vl)
+{
+  __riscv_vse8_v_u8m4_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse8_v_u8m8_m(vbool1_t mask,uint8_t* base,vuint8m8_t value,size_t vl)
+{
+  __riscv_vse8_v_u8m8_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse16_v_i16mf4_m(vbool64_t mask,int16_t* base,vint16mf4_t value,size_t vl)
+{
+  __riscv_vse16_v_i16mf4_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse16_v_i16mf2_m(vbool32_t mask,int16_t* base,vint16mf2_t value,size_t vl)
+{
+  __riscv_vse16_v_i16mf2_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse16_v_i16m1_m(vbool16_t mask,int16_t* base,vint16m1_t value,size_t vl)
+{
+  __riscv_vse16_v_i16m1_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse16_v_i16m2_m(vbool8_t mask,int16_t* base,vint16m2_t value,size_t vl)
+{
+  __riscv_vse16_v_i16m2_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse16_v_i16m4_m(vbool4_t mask,int16_t* base,vint16m4_t value,size_t vl)
+{
+  __riscv_vse16_v_i16m4_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse16_v_i16m8_m(vbool2_t mask,int16_t* base,vint16m8_t value,size_t vl)
+{
+  __riscv_vse16_v_i16m8_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse16_v_u16mf4_m(vbool64_t mask,uint16_t* base,vuint16mf4_t value,size_t vl)
+{
+  __riscv_vse16_v_u16mf4_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse16_v_u16mf2_m(vbool32_t mask,uint16_t* base,vuint16mf2_t value,size_t vl)
+{
+  __riscv_vse16_v_u16mf2_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse16_v_u16m1_m(vbool16_t mask,uint16_t* base,vuint16m1_t value,size_t vl)
+{
+  __riscv_vse16_v_u16m1_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse16_v_u16m2_m(vbool8_t mask,uint16_t* base,vuint16m2_t value,size_t vl)
+{
+  __riscv_vse16_v_u16m2_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse16_v_u16m4_m(vbool4_t mask,uint16_t* base,vuint16m4_t value,size_t vl)
+{
+  __riscv_vse16_v_u16m4_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse16_v_u16m8_m(vbool2_t mask,uint16_t* base,vuint16m8_t value,size_t vl)
+{
+  __riscv_vse16_v_u16m8_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse32_v_i32mf2_m(vbool64_t mask,int32_t* base,vint32mf2_t value,size_t vl)
+{
+  __riscv_vse32_v_i32mf2_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse32_v_i32m1_m(vbool32_t mask,int32_t* base,vint32m1_t value,size_t vl)
+{
+  __riscv_vse32_v_i32m1_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse32_v_i32m2_m(vbool16_t mask,int32_t* base,vint32m2_t value,size_t vl)
+{
+  __riscv_vse32_v_i32m2_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse32_v_i32m4_m(vbool8_t mask,int32_t* base,vint32m4_t value,size_t vl)
+{
+  __riscv_vse32_v_i32m4_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse32_v_i32m8_m(vbool4_t mask,int32_t* base,vint32m8_t value,size_t vl)
+{
+  __riscv_vse32_v_i32m8_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse32_v_u32mf2_m(vbool64_t mask,uint32_t* base,vuint32mf2_t value,size_t vl)
+{
+  __riscv_vse32_v_u32mf2_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse32_v_u32m1_m(vbool32_t mask,uint32_t* base,vuint32m1_t value,size_t vl)
+{
+  __riscv_vse32_v_u32m1_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse32_v_u32m2_m(vbool16_t mask,uint32_t* base,vuint32m2_t value,size_t vl)
+{
+  __riscv_vse32_v_u32m2_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse32_v_u32m4_m(vbool8_t mask,uint32_t* base,vuint32m4_t value,size_t vl)
+{
+  __riscv_vse32_v_u32m4_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse32_v_u32m8_m(vbool4_t mask,uint32_t* base,vuint32m8_t value,size_t vl)
+{
+  __riscv_vse32_v_u32m8_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse32_v_f32mf2_m(vbool64_t mask,float* base,vfloat32mf2_t value,size_t vl)
+{
+  __riscv_vse32_v_f32mf2_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse32_v_f32m1_m(vbool32_t mask,float* base,vfloat32m1_t value,size_t vl)
+{
+  __riscv_vse32_v_f32m1_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse32_v_f32m2_m(vbool16_t mask,float* base,vfloat32m2_t value,size_t vl)
+{
+  __riscv_vse32_v_f32m2_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse32_v_f32m4_m(vbool8_t mask,float* base,vfloat32m4_t value,size_t vl)
+{
+  __riscv_vse32_v_f32m4_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse32_v_f32m8_m(vbool4_t mask,float* base,vfloat32m8_t value,size_t vl)
+{
+  __riscv_vse32_v_f32m8_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse64_v_i64m1_m(vbool64_t mask,int64_t* base,vint64m1_t value,size_t vl)
+{
+  __riscv_vse64_v_i64m1_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse64_v_i64m2_m(vbool32_t mask,int64_t* base,vint64m2_t value,size_t vl)
+{
+  __riscv_vse64_v_i64m2_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse64_v_i64m4_m(vbool16_t mask,int64_t* base,vint64m4_t value,size_t vl)
+{
+  __riscv_vse64_v_i64m4_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse64_v_i64m8_m(vbool8_t mask,int64_t* base,vint64m8_t value,size_t vl)
+{
+  __riscv_vse64_v_i64m8_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse64_v_u64m1_m(vbool64_t mask,uint64_t* base,vuint64m1_t value,size_t vl)
+{
+  __riscv_vse64_v_u64m1_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse64_v_u64m2_m(vbool32_t mask,uint64_t* base,vuint64m2_t value,size_t vl)
+{
+  __riscv_vse64_v_u64m2_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse64_v_u64m4_m(vbool16_t mask,uint64_t* base,vuint64m4_t value,size_t vl)
+{
+  __riscv_vse64_v_u64m4_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse64_v_u64m8_m(vbool8_t mask,uint64_t* base,vuint64m8_t value,size_t vl)
+{
+  __riscv_vse64_v_u64m8_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse64_v_f64m1_m(vbool64_t mask,double* base,vfloat64m1_t value,size_t vl)
+{
+  __riscv_vse64_v_f64m1_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse64_v_f64m2_m(vbool32_t mask,double* base,vfloat64m2_t value,size_t vl)
+{
+  __riscv_vse64_v_f64m2_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse64_v_f64m4_m(vbool16_t mask,double* base,vfloat64m4_t value,size_t vl)
+{
+  __riscv_vse64_v_f64m4_m(mask,base,value,31);
+}
+
+void
+test___riscv_vse64_v_f64m8_m(vbool8_t mask,double* base,vfloat64m8_t value,size_t vl)
+{
+  __riscv_vse64_v_f64m8_m(mask,base,value,31);
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vse_m-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vse_m-3.c
new file mode 100644
index 0000000..82a3da7
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vse_m-3.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void
+test___riscv_vse8_v_i8mf8_m(vbool64_t mask,int8_t* base,vint8mf8_t value,size_t vl)
+{
+  __riscv_vse8_v_i8mf8_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse8_v_i8mf4_m(vbool32_t mask,int8_t* base,vint8mf4_t value,size_t vl)
+{
+  __riscv_vse8_v_i8mf4_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse8_v_i8mf2_m(vbool16_t mask,int8_t* base,vint8mf2_t value,size_t vl)
+{
+  __riscv_vse8_v_i8mf2_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse8_v_i8m1_m(vbool8_t mask,int8_t* base,vint8m1_t value,size_t vl)
+{
+  __riscv_vse8_v_i8m1_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse8_v_i8m2_m(vbool4_t mask,int8_t* base,vint8m2_t value,size_t vl)
+{
+  __riscv_vse8_v_i8m2_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse8_v_i8m4_m(vbool2_t mask,int8_t* base,vint8m4_t value,size_t vl)
+{
+  __riscv_vse8_v_i8m4_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse8_v_i8m8_m(vbool1_t mask,int8_t* base,vint8m8_t value,size_t vl)
+{
+  __riscv_vse8_v_i8m8_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse8_v_u8mf8_m(vbool64_t mask,uint8_t* base,vuint8mf8_t value,size_t vl)
+{
+  __riscv_vse8_v_u8mf8_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse8_v_u8mf4_m(vbool32_t mask,uint8_t* base,vuint8mf4_t value,size_t vl)
+{
+  __riscv_vse8_v_u8mf4_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse8_v_u8mf2_m(vbool16_t mask,uint8_t* base,vuint8mf2_t value,size_t vl)
+{
+  __riscv_vse8_v_u8mf2_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse8_v_u8m1_m(vbool8_t mask,uint8_t* base,vuint8m1_t value,size_t vl)
+{
+  __riscv_vse8_v_u8m1_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse8_v_u8m2_m(vbool4_t mask,uint8_t* base,vuint8m2_t value,size_t vl)
+{
+  __riscv_vse8_v_u8m2_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse8_v_u8m4_m(vbool2_t mask,uint8_t* base,vuint8m4_t value,size_t vl)
+{
+  __riscv_vse8_v_u8m4_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse8_v_u8m8_m(vbool1_t mask,uint8_t* base,vuint8m8_t value,size_t vl)
+{
+  __riscv_vse8_v_u8m8_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse16_v_i16mf4_m(vbool64_t mask,int16_t* base,vint16mf4_t value,size_t vl)
+{
+  __riscv_vse16_v_i16mf4_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse16_v_i16mf2_m(vbool32_t mask,int16_t* base,vint16mf2_t value,size_t vl)
+{
+  __riscv_vse16_v_i16mf2_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse16_v_i16m1_m(vbool16_t mask,int16_t* base,vint16m1_t value,size_t vl)
+{
+  __riscv_vse16_v_i16m1_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse16_v_i16m2_m(vbool8_t mask,int16_t* base,vint16m2_t value,size_t vl)
+{
+  __riscv_vse16_v_i16m2_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse16_v_i16m4_m(vbool4_t mask,int16_t* base,vint16m4_t value,size_t vl)
+{
+  __riscv_vse16_v_i16m4_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse16_v_i16m8_m(vbool2_t mask,int16_t* base,vint16m8_t value,size_t vl)
+{
+  __riscv_vse16_v_i16m8_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse16_v_u16mf4_m(vbool64_t mask,uint16_t* base,vuint16mf4_t value,size_t vl)
+{
+  __riscv_vse16_v_u16mf4_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse16_v_u16mf2_m(vbool32_t mask,uint16_t* base,vuint16mf2_t value,size_t vl)
+{
+  __riscv_vse16_v_u16mf2_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse16_v_u16m1_m(vbool16_t mask,uint16_t* base,vuint16m1_t value,size_t vl)
+{
+  __riscv_vse16_v_u16m1_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse16_v_u16m2_m(vbool8_t mask,uint16_t* base,vuint16m2_t value,size_t vl)
+{
+  __riscv_vse16_v_u16m2_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse16_v_u16m4_m(vbool4_t mask,uint16_t* base,vuint16m4_t value,size_t vl)
+{
+  __riscv_vse16_v_u16m4_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse16_v_u16m8_m(vbool2_t mask,uint16_t* base,vuint16m8_t value,size_t vl)
+{
+  __riscv_vse16_v_u16m8_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse32_v_i32mf2_m(vbool64_t mask,int32_t* base,vint32mf2_t value,size_t vl)
+{
+  __riscv_vse32_v_i32mf2_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse32_v_i32m1_m(vbool32_t mask,int32_t* base,vint32m1_t value,size_t vl)
+{
+  __riscv_vse32_v_i32m1_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse32_v_i32m2_m(vbool16_t mask,int32_t* base,vint32m2_t value,size_t vl)
+{
+  __riscv_vse32_v_i32m2_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse32_v_i32m4_m(vbool8_t mask,int32_t* base,vint32m4_t value,size_t vl)
+{
+  __riscv_vse32_v_i32m4_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse32_v_i32m8_m(vbool4_t mask,int32_t* base,vint32m8_t value,size_t vl)
+{
+  __riscv_vse32_v_i32m8_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse32_v_u32mf2_m(vbool64_t mask,uint32_t* base,vuint32mf2_t value,size_t vl)
+{
+  __riscv_vse32_v_u32mf2_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse32_v_u32m1_m(vbool32_t mask,uint32_t* base,vuint32m1_t value,size_t vl)
+{
+  __riscv_vse32_v_u32m1_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse32_v_u32m2_m(vbool16_t mask,uint32_t* base,vuint32m2_t value,size_t vl)
+{
+  __riscv_vse32_v_u32m2_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse32_v_u32m4_m(vbool8_t mask,uint32_t* base,vuint32m4_t value,size_t vl)
+{
+  __riscv_vse32_v_u32m4_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse32_v_u32m8_m(vbool4_t mask,uint32_t* base,vuint32m8_t value,size_t vl)
+{
+  __riscv_vse32_v_u32m8_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse32_v_f32mf2_m(vbool64_t mask,float* base,vfloat32mf2_t value,size_t vl)
+{
+  __riscv_vse32_v_f32mf2_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse32_v_f32m1_m(vbool32_t mask,float* base,vfloat32m1_t value,size_t vl)
+{
+  __riscv_vse32_v_f32m1_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse32_v_f32m2_m(vbool16_t mask,float* base,vfloat32m2_t value,size_t vl)
+{
+  __riscv_vse32_v_f32m2_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse32_v_f32m4_m(vbool8_t mask,float* base,vfloat32m4_t value,size_t vl)
+{
+  __riscv_vse32_v_f32m4_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse32_v_f32m8_m(vbool4_t mask,float* base,vfloat32m8_t value,size_t vl)
+{
+  __riscv_vse32_v_f32m8_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse64_v_i64m1_m(vbool64_t mask,int64_t* base,vint64m1_t value,size_t vl)
+{
+  __riscv_vse64_v_i64m1_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse64_v_i64m2_m(vbool32_t mask,int64_t* base,vint64m2_t value,size_t vl)
+{
+  __riscv_vse64_v_i64m2_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse64_v_i64m4_m(vbool16_t mask,int64_t* base,vint64m4_t value,size_t vl)
+{
+  __riscv_vse64_v_i64m4_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse64_v_i64m8_m(vbool8_t mask,int64_t* base,vint64m8_t value,size_t vl)
+{
+  __riscv_vse64_v_i64m8_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse64_v_u64m1_m(vbool64_t mask,uint64_t* base,vuint64m1_t value,size_t vl)
+{
+  __riscv_vse64_v_u64m1_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse64_v_u64m2_m(vbool32_t mask,uint64_t* base,vuint64m2_t value,size_t vl)
+{
+  __riscv_vse64_v_u64m2_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse64_v_u64m4_m(vbool16_t mask,uint64_t* base,vuint64m4_t value,size_t vl)
+{
+  __riscv_vse64_v_u64m4_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse64_v_u64m8_m(vbool8_t mask,uint64_t* base,vuint64m8_t value,size_t vl)
+{
+  __riscv_vse64_v_u64m8_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse64_v_f64m1_m(vbool64_t mask,double* base,vfloat64m1_t value,size_t vl)
+{
+  __riscv_vse64_v_f64m1_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse64_v_f64m2_m(vbool32_t mask,double* base,vfloat64m2_t value,size_t vl)
+{
+  __riscv_vse64_v_f64m2_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse64_v_f64m4_m(vbool16_t mask,double* base,vfloat64m4_t value,size_t vl)
+{
+  __riscv_vse64_v_f64m4_m(mask,base,value,32);
+}
+
+void
+test___riscv_vse64_v_f64m8_m(vbool8_t mask,double* base,vfloat64m8_t value,size_t vl)
+{
+  __riscv_vse64_v_f64m8_m(mask,base,value,32);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vse8\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vse16\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vse32\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vse64\.v\s+v[0-9]+,\s*0\([a-x0-9]+\),\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei16_v-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei16_v-1.c
new file mode 100644
index 0000000..3ae8e09
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei16_v-1.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei16_v_i8mf8(int8_t* base,vuint16mf4_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8mf8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i8mf4(int8_t* base,vuint16mf2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8mf4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i8mf2(int8_t* base,vuint16m1_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i8m1(int8_t* base,vuint16m2_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i8m2(int8_t* base,vuint16m4_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i8m4(int8_t* base,vuint16m8_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i16mf4(int16_t* base,vuint16mf4_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16mf4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i16mf2(int16_t* base,vuint16mf2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i16m1(int16_t* base,vuint16m1_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i16m2(int16_t* base,vuint16m2_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i16m4(int16_t* base,vuint16m4_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i16m8(int16_t* base,vuint16m8_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i32mf2(int32_t* base,vuint16mf4_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i32mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i32m1(int32_t* base,vuint16mf2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i32m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i32m2(int32_t* base,vuint16m1_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i32m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i32m4(int32_t* base,vuint16m2_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i32m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i32m8(int32_t* base,vuint16m4_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i32m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i64m1(int64_t* base,vuint16mf4_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i64m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i64m2(int64_t* base,vuint16mf2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i64m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i64m4(int64_t* base,vuint16m1_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i64m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i64m8(int64_t* base,vuint16m2_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i64m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u8mf8(uint8_t* base,vuint16mf4_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8mf8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u8mf4(uint8_t* base,vuint16mf2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8mf4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u8mf2(uint8_t* base,vuint16m1_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u8m1(uint8_t* base,vuint16m2_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u8m2(uint8_t* base,vuint16m4_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u8m4(uint8_t* base,vuint16m8_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u16mf4(uint16_t* base,vuint16mf4_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16mf4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u16mf2(uint16_t* base,vuint16mf2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u16m1(uint16_t* base,vuint16m1_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u16m2(uint16_t* base,vuint16m2_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u16m4(uint16_t* base,vuint16m4_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u16m8(uint16_t* base,vuint16m8_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u32mf2(uint32_t* base,vuint16mf4_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u32mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u32m1(uint32_t* base,vuint16mf2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u32m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u32m2(uint32_t* base,vuint16m1_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u32m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u32m4(uint32_t* base,vuint16m2_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u32m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u32m8(uint32_t* base,vuint16m4_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u32m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u64m1(uint64_t* base,vuint16mf4_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u64m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u64m2(uint64_t* base,vuint16mf2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u64m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u64m4(uint64_t* base,vuint16m1_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u64m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u64m8(uint64_t* base,vuint16m2_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u64m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_f32mf2(float* base,vuint16mf4_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f32mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_f32m1(float* base,vuint16mf2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f32m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_f32m2(float* base,vuint16m1_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f32m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_f32m4(float* base,vuint16m2_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f32m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_f32m8(float* base,vuint16m4_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f32m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_f64m1(double* base,vuint16mf4_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f64m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_f64m2(double* base,vuint16mf2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f64m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_f64m4(double* base,vuint16m1_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f64m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_f64m8(double* base,vuint16m2_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f64m8(base,bindex,value,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei16_v-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei16_v-2.c
new file mode 100644
index 0000000..4d900e2
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei16_v-2.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei16_v_i8mf8(int8_t* base,vuint16mf4_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8mf8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i8mf4(int8_t* base,vuint16mf2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8mf4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i8mf2(int8_t* base,vuint16m1_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i8m1(int8_t* base,vuint16m2_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i8m2(int8_t* base,vuint16m4_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i8m4(int8_t* base,vuint16m8_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i16mf4(int16_t* base,vuint16mf4_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16mf4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i16mf2(int16_t* base,vuint16mf2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i16m1(int16_t* base,vuint16m1_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i16m2(int16_t* base,vuint16m2_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i16m4(int16_t* base,vuint16m4_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i16m8(int16_t* base,vuint16m8_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i32mf2(int32_t* base,vuint16mf4_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i32mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i32m1(int32_t* base,vuint16mf2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i32m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i32m2(int32_t* base,vuint16m1_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i32m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i32m4(int32_t* base,vuint16m2_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i32m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i32m8(int32_t* base,vuint16m4_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i32m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i64m1(int64_t* base,vuint16mf4_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i64m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i64m2(int64_t* base,vuint16mf2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i64m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i64m4(int64_t* base,vuint16m1_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i64m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i64m8(int64_t* base,vuint16m2_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i64m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u8mf8(uint8_t* base,vuint16mf4_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8mf8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u8mf4(uint8_t* base,vuint16mf2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8mf4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u8mf2(uint8_t* base,vuint16m1_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u8m1(uint8_t* base,vuint16m2_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u8m2(uint8_t* base,vuint16m4_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u8m4(uint8_t* base,vuint16m8_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u16mf4(uint16_t* base,vuint16mf4_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16mf4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u16mf2(uint16_t* base,vuint16mf2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u16m1(uint16_t* base,vuint16m1_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u16m2(uint16_t* base,vuint16m2_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u16m4(uint16_t* base,vuint16m4_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u16m8(uint16_t* base,vuint16m8_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u32mf2(uint32_t* base,vuint16mf4_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u32mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u32m1(uint32_t* base,vuint16mf2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u32m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u32m2(uint32_t* base,vuint16m1_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u32m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u32m4(uint32_t* base,vuint16m2_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u32m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u32m8(uint32_t* base,vuint16m4_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u32m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u64m1(uint64_t* base,vuint16mf4_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u64m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u64m2(uint64_t* base,vuint16mf2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u64m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u64m4(uint64_t* base,vuint16m1_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u64m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u64m8(uint64_t* base,vuint16m2_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u64m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_f32mf2(float* base,vuint16mf4_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f32mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_f32m1(float* base,vuint16mf2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f32m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_f32m2(float* base,vuint16m1_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f32m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_f32m4(float* base,vuint16m2_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f32m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_f32m8(float* base,vuint16m4_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f32m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_f64m1(double* base,vuint16mf4_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f64m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_f64m2(double* base,vuint16mf2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f64m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_f64m4(double* base,vuint16m1_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f64m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_f64m8(double* base,vuint16m2_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f64m8(base,bindex,value,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei16_v-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei16_v-3.c
new file mode 100644
index 0000000..409a5df
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei16_v-3.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei16_v_i8mf8(int8_t* base,vuint16mf4_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8mf8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i8mf4(int8_t* base,vuint16mf2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8mf4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i8mf2(int8_t* base,vuint16m1_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i8m1(int8_t* base,vuint16m2_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i8m2(int8_t* base,vuint16m4_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i8m4(int8_t* base,vuint16m8_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i16mf4(int16_t* base,vuint16mf4_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16mf4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i16mf2(int16_t* base,vuint16mf2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i16m1(int16_t* base,vuint16m1_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i16m2(int16_t* base,vuint16m2_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i16m4(int16_t* base,vuint16m4_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i16m8(int16_t* base,vuint16m8_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i32mf2(int32_t* base,vuint16mf4_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i32mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i32m1(int32_t* base,vuint16mf2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i32m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i32m2(int32_t* base,vuint16m1_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i32m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i32m4(int32_t* base,vuint16m2_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i32m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i32m8(int32_t* base,vuint16m4_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i32m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i64m1(int64_t* base,vuint16mf4_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i64m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i64m2(int64_t* base,vuint16mf2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i64m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i64m4(int64_t* base,vuint16m1_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i64m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i64m8(int64_t* base,vuint16m2_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i64m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u8mf8(uint8_t* base,vuint16mf4_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8mf8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u8mf4(uint8_t* base,vuint16mf2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8mf4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u8mf2(uint8_t* base,vuint16m1_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u8m1(uint8_t* base,vuint16m2_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u8m2(uint8_t* base,vuint16m4_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u8m4(uint8_t* base,vuint16m8_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u16mf4(uint16_t* base,vuint16mf4_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16mf4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u16mf2(uint16_t* base,vuint16mf2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u16m1(uint16_t* base,vuint16m1_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u16m2(uint16_t* base,vuint16m2_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u16m4(uint16_t* base,vuint16m4_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u16m8(uint16_t* base,vuint16m8_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u32mf2(uint32_t* base,vuint16mf4_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u32mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u32m1(uint32_t* base,vuint16mf2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u32m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u32m2(uint32_t* base,vuint16m1_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u32m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u32m4(uint32_t* base,vuint16m2_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u32m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u32m8(uint32_t* base,vuint16m4_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u32m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u64m1(uint64_t* base,vuint16mf4_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u64m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u64m2(uint64_t* base,vuint16mf2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u64m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u64m4(uint64_t* base,vuint16m1_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u64m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u64m8(uint64_t* base,vuint16m2_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u64m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_f32mf2(float* base,vuint16mf4_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f32mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_f32m1(float* base,vuint16mf2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f32m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_f32m2(float* base,vuint16m1_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f32m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_f32m4(float* base,vuint16m2_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f32m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_f32m8(float* base,vuint16m4_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f32m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_f64m1(double* base,vuint16mf4_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f64m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_f64m2(double* base,vuint16mf2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f64m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_f64m4(double* base,vuint16m1_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f64m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_f64m8(double* base,vuint16m2_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f64m8(base,bindex,value,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei16_v_m-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei16_v_m-1.c
new file mode 100644
index 0000000..ad67492
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei16_v_m-1.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei16_v_i8mf8_m(vbool64_t mask,int8_t* base,vuint16mf4_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8mf8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i8mf4_m(vbool32_t mask,int8_t* base,vuint16mf2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8mf4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i8mf2_m(vbool16_t mask,int8_t* base,vuint16m1_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i8m1_m(vbool8_t mask,int8_t* base,vuint16m2_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i8m2_m(vbool4_t mask,int8_t* base,vuint16m4_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i8m4_m(vbool2_t mask,int8_t* base,vuint16m8_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i16mf4_m(vbool64_t mask,int16_t* base,vuint16mf4_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16mf4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i16mf2_m(vbool32_t mask,int16_t* base,vuint16mf2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i16m1_m(vbool16_t mask,int16_t* base,vuint16m1_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i16m2_m(vbool8_t mask,int16_t* base,vuint16m2_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i16m4_m(vbool4_t mask,int16_t* base,vuint16m4_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i16m8_m(vbool2_t mask,int16_t* base,vuint16m8_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i32mf2_m(vbool64_t mask,int32_t* base,vuint16mf4_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i32mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i32m1_m(vbool32_t mask,int32_t* base,vuint16mf2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i32m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i32m2_m(vbool16_t mask,int32_t* base,vuint16m1_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i32m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i32m4_m(vbool8_t mask,int32_t* base,vuint16m2_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i32m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i32m8_m(vbool4_t mask,int32_t* base,vuint16m4_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i32m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i64m1_m(vbool64_t mask,int64_t* base,vuint16mf4_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i64m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i64m2_m(vbool32_t mask,int64_t* base,vuint16mf2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i64m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i64m4_m(vbool16_t mask,int64_t* base,vuint16m1_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i64m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_i64m8_m(vbool8_t mask,int64_t* base,vuint16m2_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i64m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u8mf8_m(vbool64_t mask,uint8_t* base,vuint16mf4_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8mf8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u8mf4_m(vbool32_t mask,uint8_t* base,vuint16mf2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8mf4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u8mf2_m(vbool16_t mask,uint8_t* base,vuint16m1_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u8m1_m(vbool8_t mask,uint8_t* base,vuint16m2_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u8m2_m(vbool4_t mask,uint8_t* base,vuint16m4_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u8m4_m(vbool2_t mask,uint8_t* base,vuint16m8_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u16mf4_m(vbool64_t mask,uint16_t* base,vuint16mf4_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16mf4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u16mf2_m(vbool32_t mask,uint16_t* base,vuint16mf2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u16m1_m(vbool16_t mask,uint16_t* base,vuint16m1_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u16m2_m(vbool8_t mask,uint16_t* base,vuint16m2_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u16m4_m(vbool4_t mask,uint16_t* base,vuint16m4_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u16m8_m(vbool2_t mask,uint16_t* base,vuint16m8_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u32mf2_m(vbool64_t mask,uint32_t* base,vuint16mf4_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u32mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u32m1_m(vbool32_t mask,uint32_t* base,vuint16mf2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u32m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u32m2_m(vbool16_t mask,uint32_t* base,vuint16m1_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u32m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u32m4_m(vbool8_t mask,uint32_t* base,vuint16m2_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u32m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u32m8_m(vbool4_t mask,uint32_t* base,vuint16m4_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u32m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u64m1_m(vbool64_t mask,uint64_t* base,vuint16mf4_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u64m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u64m2_m(vbool32_t mask,uint64_t* base,vuint16mf2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u64m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u64m4_m(vbool16_t mask,uint64_t* base,vuint16m1_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u64m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_u64m8_m(vbool8_t mask,uint64_t* base,vuint16m2_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u64m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_f32mf2_m(vbool64_t mask,float* base,vuint16mf4_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f32mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_f32m1_m(vbool32_t mask,float* base,vuint16mf2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f32m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_f32m2_m(vbool16_t mask,float* base,vuint16m1_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f32m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_f32m4_m(vbool8_t mask,float* base,vuint16m2_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f32m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_f32m8_m(vbool4_t mask,float* base,vuint16m4_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f32m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_f64m1_m(vbool64_t mask,double* base,vuint16mf4_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f64m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_f64m2_m(vbool32_t mask,double* base,vuint16mf2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f64m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_f64m4_m(vbool16_t mask,double* base,vuint16m1_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f64m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei16_v_f64m8_m(vbool8_t mask,double* base,vuint16m2_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f64m8_m(mask,base,bindex,value,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei16_v_m-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei16_v_m-2.c
new file mode 100644
index 0000000..8585c4d
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei16_v_m-2.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei16_v_i8mf8_m(vbool64_t mask,int8_t* base,vuint16mf4_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8mf8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i8mf4_m(vbool32_t mask,int8_t* base,vuint16mf2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8mf4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i8mf2_m(vbool16_t mask,int8_t* base,vuint16m1_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i8m1_m(vbool8_t mask,int8_t* base,vuint16m2_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i8m2_m(vbool4_t mask,int8_t* base,vuint16m4_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i8m4_m(vbool2_t mask,int8_t* base,vuint16m8_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i16mf4_m(vbool64_t mask,int16_t* base,vuint16mf4_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16mf4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i16mf2_m(vbool32_t mask,int16_t* base,vuint16mf2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i16m1_m(vbool16_t mask,int16_t* base,vuint16m1_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i16m2_m(vbool8_t mask,int16_t* base,vuint16m2_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i16m4_m(vbool4_t mask,int16_t* base,vuint16m4_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i16m8_m(vbool2_t mask,int16_t* base,vuint16m8_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i32mf2_m(vbool64_t mask,int32_t* base,vuint16mf4_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i32mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i32m1_m(vbool32_t mask,int32_t* base,vuint16mf2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i32m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i32m2_m(vbool16_t mask,int32_t* base,vuint16m1_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i32m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i32m4_m(vbool8_t mask,int32_t* base,vuint16m2_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i32m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i32m8_m(vbool4_t mask,int32_t* base,vuint16m4_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i32m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i64m1_m(vbool64_t mask,int64_t* base,vuint16mf4_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i64m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i64m2_m(vbool32_t mask,int64_t* base,vuint16mf2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i64m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i64m4_m(vbool16_t mask,int64_t* base,vuint16m1_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i64m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_i64m8_m(vbool8_t mask,int64_t* base,vuint16m2_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i64m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u8mf8_m(vbool64_t mask,uint8_t* base,vuint16mf4_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8mf8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u8mf4_m(vbool32_t mask,uint8_t* base,vuint16mf2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8mf4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u8mf2_m(vbool16_t mask,uint8_t* base,vuint16m1_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u8m1_m(vbool8_t mask,uint8_t* base,vuint16m2_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u8m2_m(vbool4_t mask,uint8_t* base,vuint16m4_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u8m4_m(vbool2_t mask,uint8_t* base,vuint16m8_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u16mf4_m(vbool64_t mask,uint16_t* base,vuint16mf4_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16mf4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u16mf2_m(vbool32_t mask,uint16_t* base,vuint16mf2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u16m1_m(vbool16_t mask,uint16_t* base,vuint16m1_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u16m2_m(vbool8_t mask,uint16_t* base,vuint16m2_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u16m4_m(vbool4_t mask,uint16_t* base,vuint16m4_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u16m8_m(vbool2_t mask,uint16_t* base,vuint16m8_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u32mf2_m(vbool64_t mask,uint32_t* base,vuint16mf4_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u32mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u32m1_m(vbool32_t mask,uint32_t* base,vuint16mf2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u32m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u32m2_m(vbool16_t mask,uint32_t* base,vuint16m1_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u32m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u32m4_m(vbool8_t mask,uint32_t* base,vuint16m2_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u32m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u32m8_m(vbool4_t mask,uint32_t* base,vuint16m4_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u32m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u64m1_m(vbool64_t mask,uint64_t* base,vuint16mf4_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u64m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u64m2_m(vbool32_t mask,uint64_t* base,vuint16mf2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u64m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u64m4_m(vbool16_t mask,uint64_t* base,vuint16m1_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u64m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_u64m8_m(vbool8_t mask,uint64_t* base,vuint16m2_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u64m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_f32mf2_m(vbool64_t mask,float* base,vuint16mf4_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f32mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_f32m1_m(vbool32_t mask,float* base,vuint16mf2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f32m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_f32m2_m(vbool16_t mask,float* base,vuint16m1_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f32m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_f32m4_m(vbool8_t mask,float* base,vuint16m2_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f32m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_f32m8_m(vbool4_t mask,float* base,vuint16m4_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f32m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_f64m1_m(vbool64_t mask,double* base,vuint16mf4_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f64m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_f64m2_m(vbool32_t mask,double* base,vuint16mf2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f64m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_f64m4_m(vbool16_t mask,double* base,vuint16m1_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f64m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei16_v_f64m8_m(vbool8_t mask,double* base,vuint16m2_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f64m8_m(mask,base,bindex,value,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei16_v_m-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei16_v_m-3.c
new file mode 100644
index 0000000..c032df5
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei16_v_m-3.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei16_v_i8mf8_m(vbool64_t mask,int8_t* base,vuint16mf4_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8mf8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i8mf4_m(vbool32_t mask,int8_t* base,vuint16mf2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8mf4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i8mf2_m(vbool16_t mask,int8_t* base,vuint16m1_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i8m1_m(vbool8_t mask,int8_t* base,vuint16m2_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i8m2_m(vbool4_t mask,int8_t* base,vuint16m4_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i8m4_m(vbool2_t mask,int8_t* base,vuint16m8_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i8m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i16mf4_m(vbool64_t mask,int16_t* base,vuint16mf4_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16mf4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i16mf2_m(vbool32_t mask,int16_t* base,vuint16mf2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i16m1_m(vbool16_t mask,int16_t* base,vuint16m1_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i16m2_m(vbool8_t mask,int16_t* base,vuint16m2_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i16m4_m(vbool4_t mask,int16_t* base,vuint16m4_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i16m8_m(vbool2_t mask,int16_t* base,vuint16m8_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i16m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i32mf2_m(vbool64_t mask,int32_t* base,vuint16mf4_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i32mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i32m1_m(vbool32_t mask,int32_t* base,vuint16mf2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i32m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i32m2_m(vbool16_t mask,int32_t* base,vuint16m1_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i32m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i32m4_m(vbool8_t mask,int32_t* base,vuint16m2_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i32m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i32m8_m(vbool4_t mask,int32_t* base,vuint16m4_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i32m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i64m1_m(vbool64_t mask,int64_t* base,vuint16mf4_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i64m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i64m2_m(vbool32_t mask,int64_t* base,vuint16mf2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i64m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i64m4_m(vbool16_t mask,int64_t* base,vuint16m1_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i64m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_i64m8_m(vbool8_t mask,int64_t* base,vuint16m2_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_i64m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u8mf8_m(vbool64_t mask,uint8_t* base,vuint16mf4_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8mf8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u8mf4_m(vbool32_t mask,uint8_t* base,vuint16mf2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8mf4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u8mf2_m(vbool16_t mask,uint8_t* base,vuint16m1_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u8m1_m(vbool8_t mask,uint8_t* base,vuint16m2_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u8m2_m(vbool4_t mask,uint8_t* base,vuint16m4_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u8m4_m(vbool2_t mask,uint8_t* base,vuint16m8_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u8m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u16mf4_m(vbool64_t mask,uint16_t* base,vuint16mf4_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16mf4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u16mf2_m(vbool32_t mask,uint16_t* base,vuint16mf2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u16m1_m(vbool16_t mask,uint16_t* base,vuint16m1_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u16m2_m(vbool8_t mask,uint16_t* base,vuint16m2_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u16m4_m(vbool4_t mask,uint16_t* base,vuint16m4_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u16m8_m(vbool2_t mask,uint16_t* base,vuint16m8_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u16m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u32mf2_m(vbool64_t mask,uint32_t* base,vuint16mf4_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u32mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u32m1_m(vbool32_t mask,uint32_t* base,vuint16mf2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u32m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u32m2_m(vbool16_t mask,uint32_t* base,vuint16m1_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u32m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u32m4_m(vbool8_t mask,uint32_t* base,vuint16m2_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u32m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u32m8_m(vbool4_t mask,uint32_t* base,vuint16m4_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u32m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u64m1_m(vbool64_t mask,uint64_t* base,vuint16mf4_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u64m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u64m2_m(vbool32_t mask,uint64_t* base,vuint16mf2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u64m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u64m4_m(vbool16_t mask,uint64_t* base,vuint16m1_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u64m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_u64m8_m(vbool8_t mask,uint64_t* base,vuint16m2_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_u64m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_f32mf2_m(vbool64_t mask,float* base,vuint16mf4_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f32mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_f32m1_m(vbool32_t mask,float* base,vuint16mf2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f32m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_f32m2_m(vbool16_t mask,float* base,vuint16m1_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f32m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_f32m4_m(vbool8_t mask,float* base,vuint16m2_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f32m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_f32m8_m(vbool4_t mask,float* base,vuint16m4_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f32m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_f64m1_m(vbool64_t mask,double* base,vuint16mf4_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f64m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_f64m2_m(vbool32_t mask,double* base,vuint16mf2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f64m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_f64m4_m(vbool16_t mask,double* base,vuint16m1_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f64m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei16_v_f64m8_m(vbool8_t mask,double* base,vuint16m2_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei16_v_f64m8_m(mask,base,bindex,value,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei32_v-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei32_v-1.c
new file mode 100644
index 0000000..87b11ce
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei32_v-1.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei32_v_i8mf8(int8_t* base,vuint32mf2_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i8mf8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i8mf4(int8_t* base,vuint32m1_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i8mf4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i8mf2(int8_t* base,vuint32m2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i8mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i8m1(int8_t* base,vuint32m4_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i8m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i8m2(int8_t* base,vuint32m8_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i8m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i16mf4(int16_t* base,vuint32mf2_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i16mf4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i16mf2(int16_t* base,vuint32m1_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i16mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i16m1(int16_t* base,vuint32m2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i16m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i16m2(int16_t* base,vuint32m4_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i16m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i16m4(int16_t* base,vuint32m8_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i16m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i32mf2(int32_t* base,vuint32mf2_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i32mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i32m1(int32_t* base,vuint32m1_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i32m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i32m2(int32_t* base,vuint32m2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i32m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i32m4(int32_t* base,vuint32m4_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i32m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i32m8(int32_t* base,vuint32m8_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i32m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i64m1(int64_t* base,vuint32mf2_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i64m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i64m2(int64_t* base,vuint32m1_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i64m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i64m4(int64_t* base,vuint32m2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i64m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i64m8(int64_t* base,vuint32m4_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i64m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u8mf8(uint8_t* base,vuint32mf2_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u8mf8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u8mf4(uint8_t* base,vuint32m1_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u8mf4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u8mf2(uint8_t* base,vuint32m2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u8mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u8m1(uint8_t* base,vuint32m4_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u8m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u8m2(uint8_t* base,vuint32m8_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u8m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u16mf4(uint16_t* base,vuint32mf2_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u16mf4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u16mf2(uint16_t* base,vuint32m1_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u16mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u16m1(uint16_t* base,vuint32m2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u16m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u16m2(uint16_t* base,vuint32m4_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u16m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u16m4(uint16_t* base,vuint32m8_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u16m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u32mf2(uint32_t* base,vuint32mf2_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u32mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u32m1(uint32_t* base,vuint32m1_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u32m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u32m2(uint32_t* base,vuint32m2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u32m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u32m4(uint32_t* base,vuint32m4_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u32m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u32m8(uint32_t* base,vuint32m8_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u32m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u64m1(uint64_t* base,vuint32mf2_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u64m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u64m2(uint64_t* base,vuint32m1_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u64m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u64m4(uint64_t* base,vuint32m2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u64m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u64m8(uint64_t* base,vuint32m4_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u64m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_f32mf2(float* base,vuint32mf2_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f32mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_f32m1(float* base,vuint32m1_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f32m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_f32m2(float* base,vuint32m2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f32m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_f32m4(float* base,vuint32m4_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f32m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_f32m8(float* base,vuint32m8_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f32m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_f64m1(double* base,vuint32mf2_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f64m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_f64m2(double* base,vuint32m1_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f64m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_f64m4(double* base,vuint32m2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f64m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_f64m8(double* base,vuint32m4_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f64m8(base,bindex,value,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei32_v-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei32_v-2.c
new file mode 100644
index 0000000..c9c25a0
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei32_v-2.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei32_v_i8mf8(int8_t* base,vuint32mf2_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i8mf8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i8mf4(int8_t* base,vuint32m1_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i8mf4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i8mf2(int8_t* base,vuint32m2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i8mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i8m1(int8_t* base,vuint32m4_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i8m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i8m2(int8_t* base,vuint32m8_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i8m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i16mf4(int16_t* base,vuint32mf2_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i16mf4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i16mf2(int16_t* base,vuint32m1_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i16mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i16m1(int16_t* base,vuint32m2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i16m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i16m2(int16_t* base,vuint32m4_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i16m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i16m4(int16_t* base,vuint32m8_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i16m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i32mf2(int32_t* base,vuint32mf2_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i32mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i32m1(int32_t* base,vuint32m1_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i32m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i32m2(int32_t* base,vuint32m2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i32m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i32m4(int32_t* base,vuint32m4_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i32m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i32m8(int32_t* base,vuint32m8_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i32m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i64m1(int64_t* base,vuint32mf2_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i64m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i64m2(int64_t* base,vuint32m1_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i64m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i64m4(int64_t* base,vuint32m2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i64m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i64m8(int64_t* base,vuint32m4_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i64m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u8mf8(uint8_t* base,vuint32mf2_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u8mf8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u8mf4(uint8_t* base,vuint32m1_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u8mf4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u8mf2(uint8_t* base,vuint32m2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u8mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u8m1(uint8_t* base,vuint32m4_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u8m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u8m2(uint8_t* base,vuint32m8_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u8m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u16mf4(uint16_t* base,vuint32mf2_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u16mf4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u16mf2(uint16_t* base,vuint32m1_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u16mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u16m1(uint16_t* base,vuint32m2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u16m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u16m2(uint16_t* base,vuint32m4_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u16m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u16m4(uint16_t* base,vuint32m8_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u16m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u32mf2(uint32_t* base,vuint32mf2_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u32mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u32m1(uint32_t* base,vuint32m1_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u32m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u32m2(uint32_t* base,vuint32m2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u32m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u32m4(uint32_t* base,vuint32m4_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u32m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u32m8(uint32_t* base,vuint32m8_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u32m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u64m1(uint64_t* base,vuint32mf2_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u64m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u64m2(uint64_t* base,vuint32m1_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u64m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u64m4(uint64_t* base,vuint32m2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u64m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u64m8(uint64_t* base,vuint32m4_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u64m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_f32mf2(float* base,vuint32mf2_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f32mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_f32m1(float* base,vuint32m1_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f32m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_f32m2(float* base,vuint32m2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f32m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_f32m4(float* base,vuint32m4_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f32m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_f32m8(float* base,vuint32m8_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f32m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_f64m1(double* base,vuint32mf2_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f64m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_f64m2(double* base,vuint32m1_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f64m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_f64m4(double* base,vuint32m2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f64m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_f64m8(double* base,vuint32m4_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f64m8(base,bindex,value,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei32_v-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei32_v-3.c
new file mode 100644
index 0000000..574b76c
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei32_v-3.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei32_v_i8mf8(int8_t* base,vuint32mf2_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i8mf8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i8mf4(int8_t* base,vuint32m1_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i8mf4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i8mf2(int8_t* base,vuint32m2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i8mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i8m1(int8_t* base,vuint32m4_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i8m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i8m2(int8_t* base,vuint32m8_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i8m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i16mf4(int16_t* base,vuint32mf2_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i16mf4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i16mf2(int16_t* base,vuint32m1_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i16mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i16m1(int16_t* base,vuint32m2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i16m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i16m2(int16_t* base,vuint32m4_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i16m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i16m4(int16_t* base,vuint32m8_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i16m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i32mf2(int32_t* base,vuint32mf2_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i32mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i32m1(int32_t* base,vuint32m1_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i32m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i32m2(int32_t* base,vuint32m2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i32m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i32m4(int32_t* base,vuint32m4_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i32m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i32m8(int32_t* base,vuint32m8_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i32m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i64m1(int64_t* base,vuint32mf2_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i64m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i64m2(int64_t* base,vuint32m1_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i64m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i64m4(int64_t* base,vuint32m2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i64m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i64m8(int64_t* base,vuint32m4_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i64m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u8mf8(uint8_t* base,vuint32mf2_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u8mf8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u8mf4(uint8_t* base,vuint32m1_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u8mf4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u8mf2(uint8_t* base,vuint32m2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u8mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u8m1(uint8_t* base,vuint32m4_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u8m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u8m2(uint8_t* base,vuint32m8_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u8m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u16mf4(uint16_t* base,vuint32mf2_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u16mf4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u16mf2(uint16_t* base,vuint32m1_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u16mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u16m1(uint16_t* base,vuint32m2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u16m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u16m2(uint16_t* base,vuint32m4_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u16m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u16m4(uint16_t* base,vuint32m8_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u16m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u32mf2(uint32_t* base,vuint32mf2_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u32mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u32m1(uint32_t* base,vuint32m1_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u32m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u32m2(uint32_t* base,vuint32m2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u32m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u32m4(uint32_t* base,vuint32m4_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u32m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u32m8(uint32_t* base,vuint32m8_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u32m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u64m1(uint64_t* base,vuint32mf2_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u64m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u64m2(uint64_t* base,vuint32m1_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u64m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u64m4(uint64_t* base,vuint32m2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u64m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u64m8(uint64_t* base,vuint32m4_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u64m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_f32mf2(float* base,vuint32mf2_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f32mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_f32m1(float* base,vuint32m1_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f32m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_f32m2(float* base,vuint32m2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f32m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_f32m4(float* base,vuint32m4_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f32m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_f32m8(float* base,vuint32m8_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f32m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_f64m1(double* base,vuint32mf2_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f64m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_f64m2(double* base,vuint32m1_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f64m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_f64m4(double* base,vuint32m2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f64m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_f64m8(double* base,vuint32m4_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f64m8(base,bindex,value,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei32_v_m-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei32_v_m-1.c
new file mode 100644
index 0000000..16b0516
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei32_v_m-1.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei32_v_i8mf8_m(vbool64_t mask,int8_t* base,vuint32mf2_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i8mf8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i8mf4_m(vbool32_t mask,int8_t* base,vuint32m1_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i8mf4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i8mf2_m(vbool16_t mask,int8_t* base,vuint32m2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i8mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i8m1_m(vbool8_t mask,int8_t* base,vuint32m4_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i8m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i8m2_m(vbool4_t mask,int8_t* base,vuint32m8_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i8m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i16mf4_m(vbool64_t mask,int16_t* base,vuint32mf2_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i16mf4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i16mf2_m(vbool32_t mask,int16_t* base,vuint32m1_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i16mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i16m1_m(vbool16_t mask,int16_t* base,vuint32m2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i16m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i16m2_m(vbool8_t mask,int16_t* base,vuint32m4_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i16m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i16m4_m(vbool4_t mask,int16_t* base,vuint32m8_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i16m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i32mf2_m(vbool64_t mask,int32_t* base,vuint32mf2_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i32mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i32m1_m(vbool32_t mask,int32_t* base,vuint32m1_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i32m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i32m2_m(vbool16_t mask,int32_t* base,vuint32m2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i32m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i32m4_m(vbool8_t mask,int32_t* base,vuint32m4_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i32m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i32m8_m(vbool4_t mask,int32_t* base,vuint32m8_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i32m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i64m1_m(vbool64_t mask,int64_t* base,vuint32mf2_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i64m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i64m2_m(vbool32_t mask,int64_t* base,vuint32m1_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i64m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i64m4_m(vbool16_t mask,int64_t* base,vuint32m2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i64m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_i64m8_m(vbool8_t mask,int64_t* base,vuint32m4_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i64m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u8mf8_m(vbool64_t mask,uint8_t* base,vuint32mf2_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u8mf8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u8mf4_m(vbool32_t mask,uint8_t* base,vuint32m1_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u8mf4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u8mf2_m(vbool16_t mask,uint8_t* base,vuint32m2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u8mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u8m1_m(vbool8_t mask,uint8_t* base,vuint32m4_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u8m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u8m2_m(vbool4_t mask,uint8_t* base,vuint32m8_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u8m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u16mf4_m(vbool64_t mask,uint16_t* base,vuint32mf2_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u16mf4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u16mf2_m(vbool32_t mask,uint16_t* base,vuint32m1_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u16mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u16m1_m(vbool16_t mask,uint16_t* base,vuint32m2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u16m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u16m2_m(vbool8_t mask,uint16_t* base,vuint32m4_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u16m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u16m4_m(vbool4_t mask,uint16_t* base,vuint32m8_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u16m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u32mf2_m(vbool64_t mask,uint32_t* base,vuint32mf2_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u32mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u32m1_m(vbool32_t mask,uint32_t* base,vuint32m1_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u32m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u32m2_m(vbool16_t mask,uint32_t* base,vuint32m2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u32m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u32m4_m(vbool8_t mask,uint32_t* base,vuint32m4_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u32m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u32m8_m(vbool4_t mask,uint32_t* base,vuint32m8_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u32m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u64m1_m(vbool64_t mask,uint64_t* base,vuint32mf2_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u64m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u64m2_m(vbool32_t mask,uint64_t* base,vuint32m1_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u64m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u64m4_m(vbool16_t mask,uint64_t* base,vuint32m2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u64m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_u64m8_m(vbool8_t mask,uint64_t* base,vuint32m4_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u64m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_f32mf2_m(vbool64_t mask,float* base,vuint32mf2_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f32mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_f32m1_m(vbool32_t mask,float* base,vuint32m1_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f32m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_f32m2_m(vbool16_t mask,float* base,vuint32m2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f32m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_f32m4_m(vbool8_t mask,float* base,vuint32m4_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f32m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_f32m8_m(vbool4_t mask,float* base,vuint32m8_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f32m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_f64m1_m(vbool64_t mask,double* base,vuint32mf2_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f64m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_f64m2_m(vbool32_t mask,double* base,vuint32m1_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f64m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_f64m4_m(vbool16_t mask,double* base,vuint32m2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f64m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei32_v_f64m8_m(vbool8_t mask,double* base,vuint32m4_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f64m8_m(mask,base,bindex,value,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei32_v_m-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei32_v_m-2.c
new file mode 100644
index 0000000..45b4af4
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei32_v_m-2.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei32_v_i8mf8_m(vbool64_t mask,int8_t* base,vuint32mf2_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i8mf8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i8mf4_m(vbool32_t mask,int8_t* base,vuint32m1_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i8mf4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i8mf2_m(vbool16_t mask,int8_t* base,vuint32m2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i8mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i8m1_m(vbool8_t mask,int8_t* base,vuint32m4_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i8m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i8m2_m(vbool4_t mask,int8_t* base,vuint32m8_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i8m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i16mf4_m(vbool64_t mask,int16_t* base,vuint32mf2_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i16mf4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i16mf2_m(vbool32_t mask,int16_t* base,vuint32m1_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i16mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i16m1_m(vbool16_t mask,int16_t* base,vuint32m2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i16m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i16m2_m(vbool8_t mask,int16_t* base,vuint32m4_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i16m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i16m4_m(vbool4_t mask,int16_t* base,vuint32m8_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i16m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i32mf2_m(vbool64_t mask,int32_t* base,vuint32mf2_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i32mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i32m1_m(vbool32_t mask,int32_t* base,vuint32m1_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i32m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i32m2_m(vbool16_t mask,int32_t* base,vuint32m2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i32m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i32m4_m(vbool8_t mask,int32_t* base,vuint32m4_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i32m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i32m8_m(vbool4_t mask,int32_t* base,vuint32m8_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i32m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i64m1_m(vbool64_t mask,int64_t* base,vuint32mf2_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i64m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i64m2_m(vbool32_t mask,int64_t* base,vuint32m1_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i64m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i64m4_m(vbool16_t mask,int64_t* base,vuint32m2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i64m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_i64m8_m(vbool8_t mask,int64_t* base,vuint32m4_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i64m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u8mf8_m(vbool64_t mask,uint8_t* base,vuint32mf2_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u8mf8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u8mf4_m(vbool32_t mask,uint8_t* base,vuint32m1_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u8mf4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u8mf2_m(vbool16_t mask,uint8_t* base,vuint32m2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u8mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u8m1_m(vbool8_t mask,uint8_t* base,vuint32m4_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u8m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u8m2_m(vbool4_t mask,uint8_t* base,vuint32m8_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u8m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u16mf4_m(vbool64_t mask,uint16_t* base,vuint32mf2_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u16mf4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u16mf2_m(vbool32_t mask,uint16_t* base,vuint32m1_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u16mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u16m1_m(vbool16_t mask,uint16_t* base,vuint32m2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u16m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u16m2_m(vbool8_t mask,uint16_t* base,vuint32m4_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u16m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u16m4_m(vbool4_t mask,uint16_t* base,vuint32m8_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u16m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u32mf2_m(vbool64_t mask,uint32_t* base,vuint32mf2_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u32mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u32m1_m(vbool32_t mask,uint32_t* base,vuint32m1_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u32m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u32m2_m(vbool16_t mask,uint32_t* base,vuint32m2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u32m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u32m4_m(vbool8_t mask,uint32_t* base,vuint32m4_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u32m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u32m8_m(vbool4_t mask,uint32_t* base,vuint32m8_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u32m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u64m1_m(vbool64_t mask,uint64_t* base,vuint32mf2_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u64m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u64m2_m(vbool32_t mask,uint64_t* base,vuint32m1_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u64m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u64m4_m(vbool16_t mask,uint64_t* base,vuint32m2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u64m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_u64m8_m(vbool8_t mask,uint64_t* base,vuint32m4_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u64m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_f32mf2_m(vbool64_t mask,float* base,vuint32mf2_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f32mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_f32m1_m(vbool32_t mask,float* base,vuint32m1_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f32m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_f32m2_m(vbool16_t mask,float* base,vuint32m2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f32m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_f32m4_m(vbool8_t mask,float* base,vuint32m4_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f32m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_f32m8_m(vbool4_t mask,float* base,vuint32m8_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f32m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_f64m1_m(vbool64_t mask,double* base,vuint32mf2_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f64m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_f64m2_m(vbool32_t mask,double* base,vuint32m1_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f64m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_f64m4_m(vbool16_t mask,double* base,vuint32m2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f64m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei32_v_f64m8_m(vbool8_t mask,double* base,vuint32m4_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f64m8_m(mask,base,bindex,value,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei32_v_m-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei32_v_m-3.c
new file mode 100644
index 0000000..4194dc63
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei32_v_m-3.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei32_v_i8mf8_m(vbool64_t mask,int8_t* base,vuint32mf2_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i8mf8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i8mf4_m(vbool32_t mask,int8_t* base,vuint32m1_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i8mf4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i8mf2_m(vbool16_t mask,int8_t* base,vuint32m2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i8mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i8m1_m(vbool8_t mask,int8_t* base,vuint32m4_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i8m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i8m2_m(vbool4_t mask,int8_t* base,vuint32m8_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i8m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i16mf4_m(vbool64_t mask,int16_t* base,vuint32mf2_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i16mf4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i16mf2_m(vbool32_t mask,int16_t* base,vuint32m1_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i16mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i16m1_m(vbool16_t mask,int16_t* base,vuint32m2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i16m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i16m2_m(vbool8_t mask,int16_t* base,vuint32m4_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i16m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i16m4_m(vbool4_t mask,int16_t* base,vuint32m8_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i16m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i32mf2_m(vbool64_t mask,int32_t* base,vuint32mf2_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i32mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i32m1_m(vbool32_t mask,int32_t* base,vuint32m1_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i32m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i32m2_m(vbool16_t mask,int32_t* base,vuint32m2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i32m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i32m4_m(vbool8_t mask,int32_t* base,vuint32m4_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i32m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i32m8_m(vbool4_t mask,int32_t* base,vuint32m8_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i32m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i64m1_m(vbool64_t mask,int64_t* base,vuint32mf2_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i64m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i64m2_m(vbool32_t mask,int64_t* base,vuint32m1_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i64m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i64m4_m(vbool16_t mask,int64_t* base,vuint32m2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i64m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_i64m8_m(vbool8_t mask,int64_t* base,vuint32m4_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_i64m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u8mf8_m(vbool64_t mask,uint8_t* base,vuint32mf2_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u8mf8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u8mf4_m(vbool32_t mask,uint8_t* base,vuint32m1_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u8mf4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u8mf2_m(vbool16_t mask,uint8_t* base,vuint32m2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u8mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u8m1_m(vbool8_t mask,uint8_t* base,vuint32m4_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u8m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u8m2_m(vbool4_t mask,uint8_t* base,vuint32m8_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u8m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u16mf4_m(vbool64_t mask,uint16_t* base,vuint32mf2_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u16mf4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u16mf2_m(vbool32_t mask,uint16_t* base,vuint32m1_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u16mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u16m1_m(vbool16_t mask,uint16_t* base,vuint32m2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u16m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u16m2_m(vbool8_t mask,uint16_t* base,vuint32m4_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u16m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u16m4_m(vbool4_t mask,uint16_t* base,vuint32m8_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u16m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u32mf2_m(vbool64_t mask,uint32_t* base,vuint32mf2_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u32mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u32m1_m(vbool32_t mask,uint32_t* base,vuint32m1_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u32m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u32m2_m(vbool16_t mask,uint32_t* base,vuint32m2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u32m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u32m4_m(vbool8_t mask,uint32_t* base,vuint32m4_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u32m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u32m8_m(vbool4_t mask,uint32_t* base,vuint32m8_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u32m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u64m1_m(vbool64_t mask,uint64_t* base,vuint32mf2_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u64m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u64m2_m(vbool32_t mask,uint64_t* base,vuint32m1_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u64m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u64m4_m(vbool16_t mask,uint64_t* base,vuint32m2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u64m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_u64m8_m(vbool8_t mask,uint64_t* base,vuint32m4_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_u64m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_f32mf2_m(vbool64_t mask,float* base,vuint32mf2_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f32mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_f32m1_m(vbool32_t mask,float* base,vuint32m1_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f32m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_f32m2_m(vbool16_t mask,float* base,vuint32m2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f32m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_f32m4_m(vbool8_t mask,float* base,vuint32m4_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f32m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_f32m8_m(vbool4_t mask,float* base,vuint32m8_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f32m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_f64m1_m(vbool64_t mask,double* base,vuint32mf2_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f64m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_f64m2_m(vbool32_t mask,double* base,vuint32m1_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f64m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_f64m4_m(vbool16_t mask,double* base,vuint32m2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f64m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei32_v_f64m8_m(vbool8_t mask,double* base,vuint32m4_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei32_v_f64m8_m(mask,base,bindex,value,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei64_v-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei64_v-1.c
new file mode 100644
index 0000000..7bc1e38
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei64_v-1.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei64_v_i8mf8(int8_t* base,vuint64m1_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i8mf8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_i8mf4(int8_t* base,vuint64m2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i8mf4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_i8mf2(int8_t* base,vuint64m4_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i8mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_i8m1(int8_t* base,vuint64m8_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i8m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_i16mf4(int16_t* base,vuint64m1_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i16mf4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_i16mf2(int16_t* base,vuint64m2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i16mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_i16m1(int16_t* base,vuint64m4_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i16m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_i16m2(int16_t* base,vuint64m8_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i16m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_i32mf2(int32_t* base,vuint64m1_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i32mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_i32m1(int32_t* base,vuint64m2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i32m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_i32m2(int32_t* base,vuint64m4_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i32m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_i32m4(int32_t* base,vuint64m8_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i32m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_i64m1(int64_t* base,vuint64m1_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i64m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_i64m2(int64_t* base,vuint64m2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i64m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_i64m4(int64_t* base,vuint64m4_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i64m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_i64m8(int64_t* base,vuint64m8_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i64m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_u8mf8(uint8_t* base,vuint64m1_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u8mf8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_u8mf4(uint8_t* base,vuint64m2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u8mf4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_u8mf2(uint8_t* base,vuint64m4_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u8mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_u8m1(uint8_t* base,vuint64m8_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u8m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_u16mf4(uint16_t* base,vuint64m1_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u16mf4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_u16mf2(uint16_t* base,vuint64m2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u16mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_u16m1(uint16_t* base,vuint64m4_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u16m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_u16m2(uint16_t* base,vuint64m8_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u16m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_u32mf2(uint32_t* base,vuint64m1_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u32mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_u32m1(uint32_t* base,vuint64m2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u32m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_u32m2(uint32_t* base,vuint64m4_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u32m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_u32m4(uint32_t* base,vuint64m8_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u32m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_u64m1(uint64_t* base,vuint64m1_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u64m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_u64m2(uint64_t* base,vuint64m2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u64m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_u64m4(uint64_t* base,vuint64m4_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u64m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_u64m8(uint64_t* base,vuint64m8_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u64m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_f32mf2(float* base,vuint64m1_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f32mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_f32m1(float* base,vuint64m2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f32m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_f32m2(float* base,vuint64m4_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f32m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_f32m4(float* base,vuint64m8_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f32m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_f64m1(double* base,vuint64m1_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f64m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_f64m2(double* base,vuint64m2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f64m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_f64m4(double* base,vuint64m4_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f64m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_f64m8(double* base,vuint64m8_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f64m8(base,bindex,value,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei64_v-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei64_v-2.c
new file mode 100644
index 0000000..cdc586f
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei64_v-2.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei64_v_i8mf8(int8_t* base,vuint64m1_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i8mf8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_i8mf4(int8_t* base,vuint64m2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i8mf4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_i8mf2(int8_t* base,vuint64m4_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i8mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_i8m1(int8_t* base,vuint64m8_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i8m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_i16mf4(int16_t* base,vuint64m1_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i16mf4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_i16mf2(int16_t* base,vuint64m2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i16mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_i16m1(int16_t* base,vuint64m4_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i16m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_i16m2(int16_t* base,vuint64m8_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i16m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_i32mf2(int32_t* base,vuint64m1_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i32mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_i32m1(int32_t* base,vuint64m2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i32m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_i32m2(int32_t* base,vuint64m4_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i32m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_i32m4(int32_t* base,vuint64m8_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i32m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_i64m1(int64_t* base,vuint64m1_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i64m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_i64m2(int64_t* base,vuint64m2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i64m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_i64m4(int64_t* base,vuint64m4_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i64m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_i64m8(int64_t* base,vuint64m8_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i64m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_u8mf8(uint8_t* base,vuint64m1_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u8mf8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_u8mf4(uint8_t* base,vuint64m2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u8mf4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_u8mf2(uint8_t* base,vuint64m4_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u8mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_u8m1(uint8_t* base,vuint64m8_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u8m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_u16mf4(uint16_t* base,vuint64m1_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u16mf4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_u16mf2(uint16_t* base,vuint64m2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u16mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_u16m1(uint16_t* base,vuint64m4_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u16m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_u16m2(uint16_t* base,vuint64m8_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u16m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_u32mf2(uint32_t* base,vuint64m1_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u32mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_u32m1(uint32_t* base,vuint64m2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u32m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_u32m2(uint32_t* base,vuint64m4_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u32m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_u32m4(uint32_t* base,vuint64m8_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u32m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_u64m1(uint64_t* base,vuint64m1_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u64m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_u64m2(uint64_t* base,vuint64m2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u64m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_u64m4(uint64_t* base,vuint64m4_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u64m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_u64m8(uint64_t* base,vuint64m8_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u64m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_f32mf2(float* base,vuint64m1_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f32mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_f32m1(float* base,vuint64m2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f32m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_f32m2(float* base,vuint64m4_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f32m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_f32m4(float* base,vuint64m8_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f32m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_f64m1(double* base,vuint64m1_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f64m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_f64m2(double* base,vuint64m2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f64m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_f64m4(double* base,vuint64m4_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f64m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_f64m8(double* base,vuint64m8_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f64m8(base,bindex,value,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei64_v-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei64_v-3.c
new file mode 100644
index 0000000..3af5f9f
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei64_v-3.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei64_v_i8mf8(int8_t* base,vuint64m1_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i8mf8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_i8mf4(int8_t* base,vuint64m2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i8mf4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_i8mf2(int8_t* base,vuint64m4_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i8mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_i8m1(int8_t* base,vuint64m8_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i8m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_i16mf4(int16_t* base,vuint64m1_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i16mf4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_i16mf2(int16_t* base,vuint64m2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i16mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_i16m1(int16_t* base,vuint64m4_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i16m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_i16m2(int16_t* base,vuint64m8_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i16m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_i32mf2(int32_t* base,vuint64m1_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i32mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_i32m1(int32_t* base,vuint64m2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i32m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_i32m2(int32_t* base,vuint64m4_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i32m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_i32m4(int32_t* base,vuint64m8_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i32m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_i64m1(int64_t* base,vuint64m1_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i64m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_i64m2(int64_t* base,vuint64m2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i64m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_i64m4(int64_t* base,vuint64m4_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i64m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_i64m8(int64_t* base,vuint64m8_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i64m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_u8mf8(uint8_t* base,vuint64m1_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u8mf8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_u8mf4(uint8_t* base,vuint64m2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u8mf4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_u8mf2(uint8_t* base,vuint64m4_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u8mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_u8m1(uint8_t* base,vuint64m8_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u8m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_u16mf4(uint16_t* base,vuint64m1_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u16mf4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_u16mf2(uint16_t* base,vuint64m2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u16mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_u16m1(uint16_t* base,vuint64m4_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u16m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_u16m2(uint16_t* base,vuint64m8_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u16m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_u32mf2(uint32_t* base,vuint64m1_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u32mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_u32m1(uint32_t* base,vuint64m2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u32m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_u32m2(uint32_t* base,vuint64m4_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u32m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_u32m4(uint32_t* base,vuint64m8_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u32m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_u64m1(uint64_t* base,vuint64m1_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u64m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_u64m2(uint64_t* base,vuint64m2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u64m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_u64m4(uint64_t* base,vuint64m4_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u64m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_u64m8(uint64_t* base,vuint64m8_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u64m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_f32mf2(float* base,vuint64m1_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f32mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_f32m1(float* base,vuint64m2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f32m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_f32m2(float* base,vuint64m4_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f32m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_f32m4(float* base,vuint64m8_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f32m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_f64m1(double* base,vuint64m1_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f64m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_f64m2(double* base,vuint64m2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f64m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_f64m4(double* base,vuint64m4_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f64m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_f64m8(double* base,vuint64m8_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f64m8(base,bindex,value,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei64_v_m-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei64_v_m-1.c
new file mode 100644
index 0000000..366032b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei64_v_m-1.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei64_v_i8mf8_m(vbool64_t mask,int8_t* base,vuint64m1_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i8mf8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_i8mf4_m(vbool32_t mask,int8_t* base,vuint64m2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i8mf4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_i8mf2_m(vbool16_t mask,int8_t* base,vuint64m4_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i8mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_i8m1_m(vbool8_t mask,int8_t* base,vuint64m8_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i8m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_i16mf4_m(vbool64_t mask,int16_t* base,vuint64m1_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i16mf4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_i16mf2_m(vbool32_t mask,int16_t* base,vuint64m2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i16mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_i16m1_m(vbool16_t mask,int16_t* base,vuint64m4_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i16m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_i16m2_m(vbool8_t mask,int16_t* base,vuint64m8_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i16m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_i32mf2_m(vbool64_t mask,int32_t* base,vuint64m1_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i32mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_i32m1_m(vbool32_t mask,int32_t* base,vuint64m2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i32m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_i32m2_m(vbool16_t mask,int32_t* base,vuint64m4_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i32m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_i32m4_m(vbool8_t mask,int32_t* base,vuint64m8_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i32m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_i64m1_m(vbool64_t mask,int64_t* base,vuint64m1_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i64m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_i64m2_m(vbool32_t mask,int64_t* base,vuint64m2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i64m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_i64m4_m(vbool16_t mask,int64_t* base,vuint64m4_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i64m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_i64m8_m(vbool8_t mask,int64_t* base,vuint64m8_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i64m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_u8mf8_m(vbool64_t mask,uint8_t* base,vuint64m1_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u8mf8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_u8mf4_m(vbool32_t mask,uint8_t* base,vuint64m2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u8mf4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_u8mf2_m(vbool16_t mask,uint8_t* base,vuint64m4_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u8mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_u8m1_m(vbool8_t mask,uint8_t* base,vuint64m8_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u8m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_u16mf4_m(vbool64_t mask,uint16_t* base,vuint64m1_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u16mf4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_u16mf2_m(vbool32_t mask,uint16_t* base,vuint64m2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u16mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_u16m1_m(vbool16_t mask,uint16_t* base,vuint64m4_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u16m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_u16m2_m(vbool8_t mask,uint16_t* base,vuint64m8_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u16m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_u32mf2_m(vbool64_t mask,uint32_t* base,vuint64m1_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u32mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_u32m1_m(vbool32_t mask,uint32_t* base,vuint64m2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u32m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_u32m2_m(vbool16_t mask,uint32_t* base,vuint64m4_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u32m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_u32m4_m(vbool8_t mask,uint32_t* base,vuint64m8_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u32m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_u64m1_m(vbool64_t mask,uint64_t* base,vuint64m1_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u64m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_u64m2_m(vbool32_t mask,uint64_t* base,vuint64m2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u64m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_u64m4_m(vbool16_t mask,uint64_t* base,vuint64m4_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u64m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_u64m8_m(vbool8_t mask,uint64_t* base,vuint64m8_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u64m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_f32mf2_m(vbool64_t mask,float* base,vuint64m1_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f32mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_f32m1_m(vbool32_t mask,float* base,vuint64m2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f32m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_f32m2_m(vbool16_t mask,float* base,vuint64m4_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f32m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_f32m4_m(vbool8_t mask,float* base,vuint64m8_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f32m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_f64m1_m(vbool64_t mask,double* base,vuint64m1_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f64m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_f64m2_m(vbool32_t mask,double* base,vuint64m2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f64m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_f64m4_m(vbool16_t mask,double* base,vuint64m4_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f64m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei64_v_f64m8_m(vbool8_t mask,double* base,vuint64m8_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f64m8_m(mask,base,bindex,value,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei64_v_m-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei64_v_m-2.c
new file mode 100644
index 0000000..ba50f88
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei64_v_m-2.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei64_v_i8mf8_m(vbool64_t mask,int8_t* base,vuint64m1_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i8mf8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_i8mf4_m(vbool32_t mask,int8_t* base,vuint64m2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i8mf4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_i8mf2_m(vbool16_t mask,int8_t* base,vuint64m4_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i8mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_i8m1_m(vbool8_t mask,int8_t* base,vuint64m8_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i8m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_i16mf4_m(vbool64_t mask,int16_t* base,vuint64m1_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i16mf4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_i16mf2_m(vbool32_t mask,int16_t* base,vuint64m2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i16mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_i16m1_m(vbool16_t mask,int16_t* base,vuint64m4_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i16m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_i16m2_m(vbool8_t mask,int16_t* base,vuint64m8_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i16m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_i32mf2_m(vbool64_t mask,int32_t* base,vuint64m1_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i32mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_i32m1_m(vbool32_t mask,int32_t* base,vuint64m2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i32m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_i32m2_m(vbool16_t mask,int32_t* base,vuint64m4_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i32m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_i32m4_m(vbool8_t mask,int32_t* base,vuint64m8_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i32m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_i64m1_m(vbool64_t mask,int64_t* base,vuint64m1_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i64m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_i64m2_m(vbool32_t mask,int64_t* base,vuint64m2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i64m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_i64m4_m(vbool16_t mask,int64_t* base,vuint64m4_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i64m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_i64m8_m(vbool8_t mask,int64_t* base,vuint64m8_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i64m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_u8mf8_m(vbool64_t mask,uint8_t* base,vuint64m1_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u8mf8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_u8mf4_m(vbool32_t mask,uint8_t* base,vuint64m2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u8mf4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_u8mf2_m(vbool16_t mask,uint8_t* base,vuint64m4_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u8mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_u8m1_m(vbool8_t mask,uint8_t* base,vuint64m8_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u8m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_u16mf4_m(vbool64_t mask,uint16_t* base,vuint64m1_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u16mf4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_u16mf2_m(vbool32_t mask,uint16_t* base,vuint64m2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u16mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_u16m1_m(vbool16_t mask,uint16_t* base,vuint64m4_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u16m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_u16m2_m(vbool8_t mask,uint16_t* base,vuint64m8_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u16m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_u32mf2_m(vbool64_t mask,uint32_t* base,vuint64m1_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u32mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_u32m1_m(vbool32_t mask,uint32_t* base,vuint64m2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u32m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_u32m2_m(vbool16_t mask,uint32_t* base,vuint64m4_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u32m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_u32m4_m(vbool8_t mask,uint32_t* base,vuint64m8_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u32m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_u64m1_m(vbool64_t mask,uint64_t* base,vuint64m1_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u64m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_u64m2_m(vbool32_t mask,uint64_t* base,vuint64m2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u64m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_u64m4_m(vbool16_t mask,uint64_t* base,vuint64m4_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u64m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_u64m8_m(vbool8_t mask,uint64_t* base,vuint64m8_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u64m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_f32mf2_m(vbool64_t mask,float* base,vuint64m1_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f32mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_f32m1_m(vbool32_t mask,float* base,vuint64m2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f32m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_f32m2_m(vbool16_t mask,float* base,vuint64m4_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f32m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_f32m4_m(vbool8_t mask,float* base,vuint64m8_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f32m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_f64m1_m(vbool64_t mask,double* base,vuint64m1_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f64m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_f64m2_m(vbool32_t mask,double* base,vuint64m2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f64m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_f64m4_m(vbool16_t mask,double* base,vuint64m4_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f64m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei64_v_f64m8_m(vbool8_t mask,double* base,vuint64m8_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f64m8_m(mask,base,bindex,value,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei64_v_m-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei64_v_m-3.c
new file mode 100644
index 0000000..d078323
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei64_v_m-3.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei64_v_i8mf8_m(vbool64_t mask,int8_t* base,vuint64m1_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i8mf8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_i8mf4_m(vbool32_t mask,int8_t* base,vuint64m2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i8mf4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_i8mf2_m(vbool16_t mask,int8_t* base,vuint64m4_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i8mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_i8m1_m(vbool8_t mask,int8_t* base,vuint64m8_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i8m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_i16mf4_m(vbool64_t mask,int16_t* base,vuint64m1_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i16mf4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_i16mf2_m(vbool32_t mask,int16_t* base,vuint64m2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i16mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_i16m1_m(vbool16_t mask,int16_t* base,vuint64m4_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i16m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_i16m2_m(vbool8_t mask,int16_t* base,vuint64m8_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i16m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_i32mf2_m(vbool64_t mask,int32_t* base,vuint64m1_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i32mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_i32m1_m(vbool32_t mask,int32_t* base,vuint64m2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i32m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_i32m2_m(vbool16_t mask,int32_t* base,vuint64m4_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i32m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_i32m4_m(vbool8_t mask,int32_t* base,vuint64m8_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i32m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_i64m1_m(vbool64_t mask,int64_t* base,vuint64m1_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i64m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_i64m2_m(vbool32_t mask,int64_t* base,vuint64m2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i64m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_i64m4_m(vbool16_t mask,int64_t* base,vuint64m4_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i64m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_i64m8_m(vbool8_t mask,int64_t* base,vuint64m8_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_i64m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_u8mf8_m(vbool64_t mask,uint8_t* base,vuint64m1_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u8mf8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_u8mf4_m(vbool32_t mask,uint8_t* base,vuint64m2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u8mf4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_u8mf2_m(vbool16_t mask,uint8_t* base,vuint64m4_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u8mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_u8m1_m(vbool8_t mask,uint8_t* base,vuint64m8_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u8m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_u16mf4_m(vbool64_t mask,uint16_t* base,vuint64m1_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u16mf4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_u16mf2_m(vbool32_t mask,uint16_t* base,vuint64m2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u16mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_u16m1_m(vbool16_t mask,uint16_t* base,vuint64m4_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u16m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_u16m2_m(vbool8_t mask,uint16_t* base,vuint64m8_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u16m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_u32mf2_m(vbool64_t mask,uint32_t* base,vuint64m1_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u32mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_u32m1_m(vbool32_t mask,uint32_t* base,vuint64m2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u32m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_u32m2_m(vbool16_t mask,uint32_t* base,vuint64m4_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u32m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_u32m4_m(vbool8_t mask,uint32_t* base,vuint64m8_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u32m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_u64m1_m(vbool64_t mask,uint64_t* base,vuint64m1_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u64m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_u64m2_m(vbool32_t mask,uint64_t* base,vuint64m2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u64m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_u64m4_m(vbool16_t mask,uint64_t* base,vuint64m4_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u64m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_u64m8_m(vbool8_t mask,uint64_t* base,vuint64m8_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_u64m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_f32mf2_m(vbool64_t mask,float* base,vuint64m1_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f32mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_f32m1_m(vbool32_t mask,float* base,vuint64m2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f32m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_f32m2_m(vbool16_t mask,float* base,vuint64m4_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f32m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_f32m4_m(vbool8_t mask,float* base,vuint64m8_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f32m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_f64m1_m(vbool64_t mask,double* base,vuint64m1_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f64m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_f64m2_m(vbool32_t mask,double* base,vuint64m2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f64m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_f64m4_m(vbool16_t mask,double* base,vuint64m4_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f64m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei64_v_f64m8_m(vbool8_t mask,double* base,vuint64m8_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei64_v_f64m8_m(mask,base,bindex,value,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei8_v-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei8_v-1.c
new file mode 100644
index 0000000..0adff26
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei8_v-1.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei8_v_i8mf8(int8_t* base,vuint8mf8_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8mf8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i8mf4(int8_t* base,vuint8mf4_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8mf4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i8mf2(int8_t* base,vuint8mf2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i8m1(int8_t* base,vuint8m1_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i8m2(int8_t* base,vuint8m2_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i8m4(int8_t* base,vuint8m4_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i8m8(int8_t* base,vuint8m8_t bindex,vint8m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i16mf4(int16_t* base,vuint8mf8_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16mf4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i16mf2(int16_t* base,vuint8mf4_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i16m1(int16_t* base,vuint8mf2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i16m2(int16_t* base,vuint8m1_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i16m4(int16_t* base,vuint8m2_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i16m8(int16_t* base,vuint8m4_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i32mf2(int32_t* base,vuint8mf8_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i32mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i32m1(int32_t* base,vuint8mf4_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i32m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i32m2(int32_t* base,vuint8mf2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i32m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i32m4(int32_t* base,vuint8m1_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i32m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i32m8(int32_t* base,vuint8m2_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i32m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i64m1(int64_t* base,vuint8mf8_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i64m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i64m2(int64_t* base,vuint8mf4_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i64m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i64m4(int64_t* base,vuint8mf2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i64m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i64m8(int64_t* base,vuint8m1_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i64m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u8mf8(uint8_t* base,vuint8mf8_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8mf8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u8mf4(uint8_t* base,vuint8mf4_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8mf4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u8mf2(uint8_t* base,vuint8mf2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u8m1(uint8_t* base,vuint8m1_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u8m2(uint8_t* base,vuint8m2_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u8m4(uint8_t* base,vuint8m4_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u8m8(uint8_t* base,vuint8m8_t bindex,vuint8m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u16mf4(uint16_t* base,vuint8mf8_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16mf4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u16mf2(uint16_t* base,vuint8mf4_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u16m1(uint16_t* base,vuint8mf2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u16m2(uint16_t* base,vuint8m1_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u16m4(uint16_t* base,vuint8m2_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u16m8(uint16_t* base,vuint8m4_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u32mf2(uint32_t* base,vuint8mf8_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u32mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u32m1(uint32_t* base,vuint8mf4_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u32m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u32m2(uint32_t* base,vuint8mf2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u32m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u32m4(uint32_t* base,vuint8m1_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u32m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u32m8(uint32_t* base,vuint8m2_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u32m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u64m1(uint64_t* base,vuint8mf8_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u64m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u64m2(uint64_t* base,vuint8mf4_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u64m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u64m4(uint64_t* base,vuint8mf2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u64m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u64m8(uint64_t* base,vuint8m1_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u64m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_f32mf2(float* base,vuint8mf8_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f32mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_f32m1(float* base,vuint8mf4_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f32m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_f32m2(float* base,vuint8mf2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f32m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_f32m4(float* base,vuint8m1_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f32m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_f32m8(float* base,vuint8m2_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f32m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_f64m1(double* base,vuint8mf8_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f64m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_f64m2(double* base,vuint8mf4_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f64m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_f64m4(double* base,vuint8mf2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f64m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_f64m8(double* base,vuint8m1_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f64m8(base,bindex,value,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei8_v-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei8_v-2.c
new file mode 100644
index 0000000..60624ae
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei8_v-2.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei8_v_i8mf8(int8_t* base,vuint8mf8_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8mf8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i8mf4(int8_t* base,vuint8mf4_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8mf4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i8mf2(int8_t* base,vuint8mf2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i8m1(int8_t* base,vuint8m1_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i8m2(int8_t* base,vuint8m2_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i8m4(int8_t* base,vuint8m4_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i8m8(int8_t* base,vuint8m8_t bindex,vint8m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i16mf4(int16_t* base,vuint8mf8_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16mf4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i16mf2(int16_t* base,vuint8mf4_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i16m1(int16_t* base,vuint8mf2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i16m2(int16_t* base,vuint8m1_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i16m4(int16_t* base,vuint8m2_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i16m8(int16_t* base,vuint8m4_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i32mf2(int32_t* base,vuint8mf8_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i32mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i32m1(int32_t* base,vuint8mf4_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i32m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i32m2(int32_t* base,vuint8mf2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i32m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i32m4(int32_t* base,vuint8m1_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i32m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i32m8(int32_t* base,vuint8m2_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i32m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i64m1(int64_t* base,vuint8mf8_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i64m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i64m2(int64_t* base,vuint8mf4_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i64m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i64m4(int64_t* base,vuint8mf2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i64m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i64m8(int64_t* base,vuint8m1_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i64m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u8mf8(uint8_t* base,vuint8mf8_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8mf8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u8mf4(uint8_t* base,vuint8mf4_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8mf4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u8mf2(uint8_t* base,vuint8mf2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u8m1(uint8_t* base,vuint8m1_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u8m2(uint8_t* base,vuint8m2_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u8m4(uint8_t* base,vuint8m4_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u8m8(uint8_t* base,vuint8m8_t bindex,vuint8m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u16mf4(uint16_t* base,vuint8mf8_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16mf4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u16mf2(uint16_t* base,vuint8mf4_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u16m1(uint16_t* base,vuint8mf2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u16m2(uint16_t* base,vuint8m1_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u16m4(uint16_t* base,vuint8m2_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u16m8(uint16_t* base,vuint8m4_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u32mf2(uint32_t* base,vuint8mf8_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u32mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u32m1(uint32_t* base,vuint8mf4_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u32m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u32m2(uint32_t* base,vuint8mf2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u32m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u32m4(uint32_t* base,vuint8m1_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u32m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u32m8(uint32_t* base,vuint8m2_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u32m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u64m1(uint64_t* base,vuint8mf8_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u64m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u64m2(uint64_t* base,vuint8mf4_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u64m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u64m4(uint64_t* base,vuint8mf2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u64m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u64m8(uint64_t* base,vuint8m1_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u64m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_f32mf2(float* base,vuint8mf8_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f32mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_f32m1(float* base,vuint8mf4_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f32m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_f32m2(float* base,vuint8mf2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f32m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_f32m4(float* base,vuint8m1_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f32m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_f32m8(float* base,vuint8m2_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f32m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_f64m1(double* base,vuint8mf8_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f64m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_f64m2(double* base,vuint8mf4_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f64m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_f64m4(double* base,vuint8mf2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f64m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_f64m8(double* base,vuint8m1_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f64m8(base,bindex,value,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei8_v-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei8_v-3.c
new file mode 100644
index 0000000..8f21adc
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei8_v-3.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei8_v_i8mf8(int8_t* base,vuint8mf8_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8mf8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i8mf4(int8_t* base,vuint8mf4_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8mf4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i8mf2(int8_t* base,vuint8mf2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i8m1(int8_t* base,vuint8m1_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i8m2(int8_t* base,vuint8m2_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i8m4(int8_t* base,vuint8m4_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i8m8(int8_t* base,vuint8m8_t bindex,vint8m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i16mf4(int16_t* base,vuint8mf8_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16mf4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i16mf2(int16_t* base,vuint8mf4_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i16m1(int16_t* base,vuint8mf2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i16m2(int16_t* base,vuint8m1_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i16m4(int16_t* base,vuint8m2_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i16m8(int16_t* base,vuint8m4_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i32mf2(int32_t* base,vuint8mf8_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i32mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i32m1(int32_t* base,vuint8mf4_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i32m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i32m2(int32_t* base,vuint8mf2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i32m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i32m4(int32_t* base,vuint8m1_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i32m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i32m8(int32_t* base,vuint8m2_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i32m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i64m1(int64_t* base,vuint8mf8_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i64m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i64m2(int64_t* base,vuint8mf4_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i64m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i64m4(int64_t* base,vuint8mf2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i64m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i64m8(int64_t* base,vuint8m1_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i64m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u8mf8(uint8_t* base,vuint8mf8_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8mf8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u8mf4(uint8_t* base,vuint8mf4_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8mf4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u8mf2(uint8_t* base,vuint8mf2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u8m1(uint8_t* base,vuint8m1_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u8m2(uint8_t* base,vuint8m2_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u8m4(uint8_t* base,vuint8m4_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u8m8(uint8_t* base,vuint8m8_t bindex,vuint8m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u16mf4(uint16_t* base,vuint8mf8_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16mf4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u16mf2(uint16_t* base,vuint8mf4_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u16m1(uint16_t* base,vuint8mf2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u16m2(uint16_t* base,vuint8m1_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u16m4(uint16_t* base,vuint8m2_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u16m8(uint16_t* base,vuint8m4_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u32mf2(uint32_t* base,vuint8mf8_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u32mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u32m1(uint32_t* base,vuint8mf4_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u32m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u32m2(uint32_t* base,vuint8mf2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u32m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u32m4(uint32_t* base,vuint8m1_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u32m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u32m8(uint32_t* base,vuint8m2_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u32m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u64m1(uint64_t* base,vuint8mf8_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u64m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u64m2(uint64_t* base,vuint8mf4_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u64m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u64m4(uint64_t* base,vuint8mf2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u64m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u64m8(uint64_t* base,vuint8m1_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u64m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_f32mf2(float* base,vuint8mf8_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f32mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_f32m1(float* base,vuint8mf4_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f32m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_f32m2(float* base,vuint8mf2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f32m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_f32m4(float* base,vuint8m1_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f32m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_f32m8(float* base,vuint8m2_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f32m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_f64m1(double* base,vuint8mf8_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f64m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_f64m2(double* base,vuint8mf4_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f64m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_f64m4(double* base,vuint8mf2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f64m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_f64m8(double* base,vuint8m1_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f64m8(base,bindex,value,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei8_v_m-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei8_v_m-1.c
new file mode 100644
index 0000000..3a8fdfe
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei8_v_m-1.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei8_v_i8mf8_m(vbool64_t mask,int8_t* base,vuint8mf8_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8mf8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i8mf4_m(vbool32_t mask,int8_t* base,vuint8mf4_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8mf4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i8mf2_m(vbool16_t mask,int8_t* base,vuint8mf2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i8m1_m(vbool8_t mask,int8_t* base,vuint8m1_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i8m2_m(vbool4_t mask,int8_t* base,vuint8m2_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i8m4_m(vbool2_t mask,int8_t* base,vuint8m4_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i8m8_m(vbool1_t mask,int8_t* base,vuint8m8_t bindex,vint8m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i16mf4_m(vbool64_t mask,int16_t* base,vuint8mf8_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16mf4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i16mf2_m(vbool32_t mask,int16_t* base,vuint8mf4_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i16m1_m(vbool16_t mask,int16_t* base,vuint8mf2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i16m2_m(vbool8_t mask,int16_t* base,vuint8m1_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i16m4_m(vbool4_t mask,int16_t* base,vuint8m2_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i16m8_m(vbool2_t mask,int16_t* base,vuint8m4_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i32mf2_m(vbool64_t mask,int32_t* base,vuint8mf8_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i32mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i32m1_m(vbool32_t mask,int32_t* base,vuint8mf4_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i32m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i32m2_m(vbool16_t mask,int32_t* base,vuint8mf2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i32m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i32m4_m(vbool8_t mask,int32_t* base,vuint8m1_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i32m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i32m8_m(vbool4_t mask,int32_t* base,vuint8m2_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i32m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i64m1_m(vbool64_t mask,int64_t* base,vuint8mf8_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i64m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i64m2_m(vbool32_t mask,int64_t* base,vuint8mf4_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i64m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i64m4_m(vbool16_t mask,int64_t* base,vuint8mf2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i64m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_i64m8_m(vbool8_t mask,int64_t* base,vuint8m1_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i64m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u8mf8_m(vbool64_t mask,uint8_t* base,vuint8mf8_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8mf8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u8mf4_m(vbool32_t mask,uint8_t* base,vuint8mf4_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8mf4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u8mf2_m(vbool16_t mask,uint8_t* base,vuint8mf2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u8m1_m(vbool8_t mask,uint8_t* base,vuint8m1_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u8m2_m(vbool4_t mask,uint8_t* base,vuint8m2_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u8m4_m(vbool2_t mask,uint8_t* base,vuint8m4_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u8m8_m(vbool1_t mask,uint8_t* base,vuint8m8_t bindex,vuint8m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u16mf4_m(vbool64_t mask,uint16_t* base,vuint8mf8_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16mf4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u16mf2_m(vbool32_t mask,uint16_t* base,vuint8mf4_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u16m1_m(vbool16_t mask,uint16_t* base,vuint8mf2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u16m2_m(vbool8_t mask,uint16_t* base,vuint8m1_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u16m4_m(vbool4_t mask,uint16_t* base,vuint8m2_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u16m8_m(vbool2_t mask,uint16_t* base,vuint8m4_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u32mf2_m(vbool64_t mask,uint32_t* base,vuint8mf8_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u32mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u32m1_m(vbool32_t mask,uint32_t* base,vuint8mf4_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u32m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u32m2_m(vbool16_t mask,uint32_t* base,vuint8mf2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u32m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u32m4_m(vbool8_t mask,uint32_t* base,vuint8m1_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u32m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u32m8_m(vbool4_t mask,uint32_t* base,vuint8m2_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u32m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u64m1_m(vbool64_t mask,uint64_t* base,vuint8mf8_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u64m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u64m2_m(vbool32_t mask,uint64_t* base,vuint8mf4_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u64m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u64m4_m(vbool16_t mask,uint64_t* base,vuint8mf2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u64m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_u64m8_m(vbool8_t mask,uint64_t* base,vuint8m1_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u64m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_f32mf2_m(vbool64_t mask,float* base,vuint8mf8_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f32mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_f32m1_m(vbool32_t mask,float* base,vuint8mf4_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f32m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_f32m2_m(vbool16_t mask,float* base,vuint8mf2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f32m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_f32m4_m(vbool8_t mask,float* base,vuint8m1_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f32m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_f32m8_m(vbool4_t mask,float* base,vuint8m2_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f32m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_f64m1_m(vbool64_t mask,double* base,vuint8mf8_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f64m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_f64m2_m(vbool32_t mask,double* base,vuint8mf4_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f64m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_f64m4_m(vbool16_t mask,double* base,vuint8mf2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f64m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsoxei8_v_f64m8_m(vbool8_t mask,double* base,vuint8m1_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f64m8_m(mask,base,bindex,value,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei8_v_m-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei8_v_m-2.c
new file mode 100644
index 0000000..412152c
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei8_v_m-2.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei8_v_i8mf8_m(vbool64_t mask,int8_t* base,vuint8mf8_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8mf8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i8mf4_m(vbool32_t mask,int8_t* base,vuint8mf4_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8mf4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i8mf2_m(vbool16_t mask,int8_t* base,vuint8mf2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i8m1_m(vbool8_t mask,int8_t* base,vuint8m1_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i8m2_m(vbool4_t mask,int8_t* base,vuint8m2_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i8m4_m(vbool2_t mask,int8_t* base,vuint8m4_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i8m8_m(vbool1_t mask,int8_t* base,vuint8m8_t bindex,vint8m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i16mf4_m(vbool64_t mask,int16_t* base,vuint8mf8_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16mf4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i16mf2_m(vbool32_t mask,int16_t* base,vuint8mf4_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i16m1_m(vbool16_t mask,int16_t* base,vuint8mf2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i16m2_m(vbool8_t mask,int16_t* base,vuint8m1_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i16m4_m(vbool4_t mask,int16_t* base,vuint8m2_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i16m8_m(vbool2_t mask,int16_t* base,vuint8m4_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i32mf2_m(vbool64_t mask,int32_t* base,vuint8mf8_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i32mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i32m1_m(vbool32_t mask,int32_t* base,vuint8mf4_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i32m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i32m2_m(vbool16_t mask,int32_t* base,vuint8mf2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i32m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i32m4_m(vbool8_t mask,int32_t* base,vuint8m1_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i32m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i32m8_m(vbool4_t mask,int32_t* base,vuint8m2_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i32m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i64m1_m(vbool64_t mask,int64_t* base,vuint8mf8_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i64m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i64m2_m(vbool32_t mask,int64_t* base,vuint8mf4_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i64m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i64m4_m(vbool16_t mask,int64_t* base,vuint8mf2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i64m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_i64m8_m(vbool8_t mask,int64_t* base,vuint8m1_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i64m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u8mf8_m(vbool64_t mask,uint8_t* base,vuint8mf8_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8mf8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u8mf4_m(vbool32_t mask,uint8_t* base,vuint8mf4_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8mf4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u8mf2_m(vbool16_t mask,uint8_t* base,vuint8mf2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u8m1_m(vbool8_t mask,uint8_t* base,vuint8m1_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u8m2_m(vbool4_t mask,uint8_t* base,vuint8m2_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u8m4_m(vbool2_t mask,uint8_t* base,vuint8m4_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u8m8_m(vbool1_t mask,uint8_t* base,vuint8m8_t bindex,vuint8m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u16mf4_m(vbool64_t mask,uint16_t* base,vuint8mf8_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16mf4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u16mf2_m(vbool32_t mask,uint16_t* base,vuint8mf4_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u16m1_m(vbool16_t mask,uint16_t* base,vuint8mf2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u16m2_m(vbool8_t mask,uint16_t* base,vuint8m1_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u16m4_m(vbool4_t mask,uint16_t* base,vuint8m2_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u16m8_m(vbool2_t mask,uint16_t* base,vuint8m4_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u32mf2_m(vbool64_t mask,uint32_t* base,vuint8mf8_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u32mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u32m1_m(vbool32_t mask,uint32_t* base,vuint8mf4_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u32m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u32m2_m(vbool16_t mask,uint32_t* base,vuint8mf2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u32m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u32m4_m(vbool8_t mask,uint32_t* base,vuint8m1_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u32m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u32m8_m(vbool4_t mask,uint32_t* base,vuint8m2_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u32m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u64m1_m(vbool64_t mask,uint64_t* base,vuint8mf8_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u64m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u64m2_m(vbool32_t mask,uint64_t* base,vuint8mf4_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u64m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u64m4_m(vbool16_t mask,uint64_t* base,vuint8mf2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u64m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_u64m8_m(vbool8_t mask,uint64_t* base,vuint8m1_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u64m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_f32mf2_m(vbool64_t mask,float* base,vuint8mf8_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f32mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_f32m1_m(vbool32_t mask,float* base,vuint8mf4_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f32m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_f32m2_m(vbool16_t mask,float* base,vuint8mf2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f32m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_f32m4_m(vbool8_t mask,float* base,vuint8m1_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f32m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_f32m8_m(vbool4_t mask,float* base,vuint8m2_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f32m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_f64m1_m(vbool64_t mask,double* base,vuint8mf8_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f64m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_f64m2_m(vbool32_t mask,double* base,vuint8mf4_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f64m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_f64m4_m(vbool16_t mask,double* base,vuint8mf2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f64m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsoxei8_v_f64m8_m(vbool8_t mask,double* base,vuint8m1_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f64m8_m(mask,base,bindex,value,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei8_v_m-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei8_v_m-3.c
new file mode 100644
index 0000000..c4ff5d2
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsoxei8_v_m-3.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsoxei8_v_i8mf8_m(vbool64_t mask,int8_t* base,vuint8mf8_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8mf8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i8mf4_m(vbool32_t mask,int8_t* base,vuint8mf4_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8mf4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i8mf2_m(vbool16_t mask,int8_t* base,vuint8mf2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i8m1_m(vbool8_t mask,int8_t* base,vuint8m1_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i8m2_m(vbool4_t mask,int8_t* base,vuint8m2_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i8m4_m(vbool2_t mask,int8_t* base,vuint8m4_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i8m8_m(vbool1_t mask,int8_t* base,vuint8m8_t bindex,vint8m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i8m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i16mf4_m(vbool64_t mask,int16_t* base,vuint8mf8_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16mf4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i16mf2_m(vbool32_t mask,int16_t* base,vuint8mf4_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i16m1_m(vbool16_t mask,int16_t* base,vuint8mf2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i16m2_m(vbool8_t mask,int16_t* base,vuint8m1_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i16m4_m(vbool4_t mask,int16_t* base,vuint8m2_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i16m8_m(vbool2_t mask,int16_t* base,vuint8m4_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i16m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i32mf2_m(vbool64_t mask,int32_t* base,vuint8mf8_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i32mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i32m1_m(vbool32_t mask,int32_t* base,vuint8mf4_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i32m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i32m2_m(vbool16_t mask,int32_t* base,vuint8mf2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i32m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i32m4_m(vbool8_t mask,int32_t* base,vuint8m1_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i32m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i32m8_m(vbool4_t mask,int32_t* base,vuint8m2_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i32m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i64m1_m(vbool64_t mask,int64_t* base,vuint8mf8_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i64m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i64m2_m(vbool32_t mask,int64_t* base,vuint8mf4_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i64m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i64m4_m(vbool16_t mask,int64_t* base,vuint8mf2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i64m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_i64m8_m(vbool8_t mask,int64_t* base,vuint8m1_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_i64m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u8mf8_m(vbool64_t mask,uint8_t* base,vuint8mf8_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8mf8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u8mf4_m(vbool32_t mask,uint8_t* base,vuint8mf4_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8mf4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u8mf2_m(vbool16_t mask,uint8_t* base,vuint8mf2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u8m1_m(vbool8_t mask,uint8_t* base,vuint8m1_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u8m2_m(vbool4_t mask,uint8_t* base,vuint8m2_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u8m4_m(vbool2_t mask,uint8_t* base,vuint8m4_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u8m8_m(vbool1_t mask,uint8_t* base,vuint8m8_t bindex,vuint8m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u8m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u16mf4_m(vbool64_t mask,uint16_t* base,vuint8mf8_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16mf4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u16mf2_m(vbool32_t mask,uint16_t* base,vuint8mf4_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u16m1_m(vbool16_t mask,uint16_t* base,vuint8mf2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u16m2_m(vbool8_t mask,uint16_t* base,vuint8m1_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u16m4_m(vbool4_t mask,uint16_t* base,vuint8m2_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u16m8_m(vbool2_t mask,uint16_t* base,vuint8m4_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u16m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u32mf2_m(vbool64_t mask,uint32_t* base,vuint8mf8_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u32mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u32m1_m(vbool32_t mask,uint32_t* base,vuint8mf4_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u32m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u32m2_m(vbool16_t mask,uint32_t* base,vuint8mf2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u32m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u32m4_m(vbool8_t mask,uint32_t* base,vuint8m1_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u32m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u32m8_m(vbool4_t mask,uint32_t* base,vuint8m2_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u32m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u64m1_m(vbool64_t mask,uint64_t* base,vuint8mf8_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u64m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u64m2_m(vbool32_t mask,uint64_t* base,vuint8mf4_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u64m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u64m4_m(vbool16_t mask,uint64_t* base,vuint8mf2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u64m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_u64m8_m(vbool8_t mask,uint64_t* base,vuint8m1_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_u64m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_f32mf2_m(vbool64_t mask,float* base,vuint8mf8_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f32mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_f32m1_m(vbool32_t mask,float* base,vuint8mf4_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f32m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_f32m2_m(vbool16_t mask,float* base,vuint8mf2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f32m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_f32m4_m(vbool8_t mask,float* base,vuint8m1_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f32m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_f32m8_m(vbool4_t mask,float* base,vuint8m2_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f32m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_f64m1_m(vbool64_t mask,double* base,vuint8mf8_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f64m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_f64m2_m(vbool32_t mask,double* base,vuint8mf4_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f64m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_f64m4_m(vbool16_t mask,double* base,vuint8mf2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f64m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsoxei8_v_f64m8_m(vbool8_t mask,double* base,vuint8m1_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsoxei8_v_f64m8_m(mask,base,bindex,value,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsoxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsse-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsse-1.c
new file mode 100644
index 0000000..fff498f
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsse-1.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void
+test___riscv_vsse8_v_i8mf8(int8_t* base,ptrdiff_t bstride,vint8mf8_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8mf8(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_i8mf4(int8_t* base,ptrdiff_t bstride,vint8mf4_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8mf4(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_i8mf2(int8_t* base,ptrdiff_t bstride,vint8mf2_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8mf2(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_i8m1(int8_t* base,ptrdiff_t bstride,vint8m1_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8m1(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_i8m2(int8_t* base,ptrdiff_t bstride,vint8m2_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8m2(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_i8m4(int8_t* base,ptrdiff_t bstride,vint8m4_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8m4(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_i8m8(int8_t* base,ptrdiff_t bstride,vint8m8_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8m8(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_u8mf8(uint8_t* base,ptrdiff_t bstride,vuint8mf8_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8mf8(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_u8mf4(uint8_t* base,ptrdiff_t bstride,vuint8mf4_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8mf4(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_u8mf2(uint8_t* base,ptrdiff_t bstride,vuint8mf2_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8mf2(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_u8m1(uint8_t* base,ptrdiff_t bstride,vuint8m1_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8m1(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_u8m2(uint8_t* base,ptrdiff_t bstride,vuint8m2_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8m2(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_u8m4(uint8_t* base,ptrdiff_t bstride,vuint8m4_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8m4(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_u8m8(uint8_t* base,ptrdiff_t bstride,vuint8m8_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8m8(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_i16mf4(int16_t* base,ptrdiff_t bstride,vint16mf4_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16mf4(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_i16mf2(int16_t* base,ptrdiff_t bstride,vint16mf2_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16mf2(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_i16m1(int16_t* base,ptrdiff_t bstride,vint16m1_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16m1(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_i16m2(int16_t* base,ptrdiff_t bstride,vint16m2_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16m2(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_i16m4(int16_t* base,ptrdiff_t bstride,vint16m4_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16m4(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_i16m8(int16_t* base,ptrdiff_t bstride,vint16m8_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16m8(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_u16mf4(uint16_t* base,ptrdiff_t bstride,vuint16mf4_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16mf4(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_u16mf2(uint16_t* base,ptrdiff_t bstride,vuint16mf2_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16mf2(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_u16m1(uint16_t* base,ptrdiff_t bstride,vuint16m1_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16m1(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_u16m2(uint16_t* base,ptrdiff_t bstride,vuint16m2_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16m2(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_u16m4(uint16_t* base,ptrdiff_t bstride,vuint16m4_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16m4(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_u16m8(uint16_t* base,ptrdiff_t bstride,vuint16m8_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16m8(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_i32mf2(int32_t* base,ptrdiff_t bstride,vint32mf2_t value,size_t vl)
+{
+  __riscv_vsse32_v_i32mf2(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_i32m1(int32_t* base,ptrdiff_t bstride,vint32m1_t value,size_t vl)
+{
+  __riscv_vsse32_v_i32m1(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_i32m2(int32_t* base,ptrdiff_t bstride,vint32m2_t value,size_t vl)
+{
+  __riscv_vsse32_v_i32m2(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_i32m4(int32_t* base,ptrdiff_t bstride,vint32m4_t value,size_t vl)
+{
+  __riscv_vsse32_v_i32m4(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_i32m8(int32_t* base,ptrdiff_t bstride,vint32m8_t value,size_t vl)
+{
+  __riscv_vsse32_v_i32m8(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_u32mf2(uint32_t* base,ptrdiff_t bstride,vuint32mf2_t value,size_t vl)
+{
+  __riscv_vsse32_v_u32mf2(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_u32m1(uint32_t* base,ptrdiff_t bstride,vuint32m1_t value,size_t vl)
+{
+  __riscv_vsse32_v_u32m1(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_u32m2(uint32_t* base,ptrdiff_t bstride,vuint32m2_t value,size_t vl)
+{
+  __riscv_vsse32_v_u32m2(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_u32m4(uint32_t* base,ptrdiff_t bstride,vuint32m4_t value,size_t vl)
+{
+  __riscv_vsse32_v_u32m4(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_u32m8(uint32_t* base,ptrdiff_t bstride,vuint32m8_t value,size_t vl)
+{
+  __riscv_vsse32_v_u32m8(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_f32mf2(float* base,ptrdiff_t bstride,vfloat32mf2_t value,size_t vl)
+{
+  __riscv_vsse32_v_f32mf2(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_f32m1(float* base,ptrdiff_t bstride,vfloat32m1_t value,size_t vl)
+{
+  __riscv_vsse32_v_f32m1(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_f32m2(float* base,ptrdiff_t bstride,vfloat32m2_t value,size_t vl)
+{
+  __riscv_vsse32_v_f32m2(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_f32m4(float* base,ptrdiff_t bstride,vfloat32m4_t value,size_t vl)
+{
+  __riscv_vsse32_v_f32m4(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_f32m8(float* base,ptrdiff_t bstride,vfloat32m8_t value,size_t vl)
+{
+  __riscv_vsse32_v_f32m8(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_i64m1(int64_t* base,ptrdiff_t bstride,vint64m1_t value,size_t vl)
+{
+  __riscv_vsse64_v_i64m1(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_i64m2(int64_t* base,ptrdiff_t bstride,vint64m2_t value,size_t vl)
+{
+  __riscv_vsse64_v_i64m2(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_i64m4(int64_t* base,ptrdiff_t bstride,vint64m4_t value,size_t vl)
+{
+  __riscv_vsse64_v_i64m4(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_i64m8(int64_t* base,ptrdiff_t bstride,vint64m8_t value,size_t vl)
+{
+  __riscv_vsse64_v_i64m8(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_u64m1(uint64_t* base,ptrdiff_t bstride,vuint64m1_t value,size_t vl)
+{
+  __riscv_vsse64_v_u64m1(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_u64m2(uint64_t* base,ptrdiff_t bstride,vuint64m2_t value,size_t vl)
+{
+  __riscv_vsse64_v_u64m2(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_u64m4(uint64_t* base,ptrdiff_t bstride,vuint64m4_t value,size_t vl)
+{
+  __riscv_vsse64_v_u64m4(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_u64m8(uint64_t* base,ptrdiff_t bstride,vuint64m8_t value,size_t vl)
+{
+  __riscv_vsse64_v_u64m8(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_f64m1(double* base,ptrdiff_t bstride,vfloat64m1_t value,size_t vl)
+{
+  __riscv_vsse64_v_f64m1(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_f64m2(double* base,ptrdiff_t bstride,vfloat64m2_t value,size_t vl)
+{
+  __riscv_vsse64_v_f64m2(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_f64m4(double* base,ptrdiff_t bstride,vfloat64m4_t value,size_t vl)
+{
+  __riscv_vsse64_v_f64m4(base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_f64m8(double* base,ptrdiff_t bstride,vfloat64m8_t value,size_t vl)
+{
+  __riscv_vsse64_v_f64m8(base,bstride,value,vl);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsse64\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsse64\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsse64\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsse64\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsse-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsse-2.c
new file mode 100644
index 0000000..921bc0d0
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsse-2.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void
+test___riscv_vsse8_v_i8mf8(int8_t* base,ptrdiff_t bstride,vint8mf8_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8mf8(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse8_v_i8mf4(int8_t* base,ptrdiff_t bstride,vint8mf4_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8mf4(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse8_v_i8mf2(int8_t* base,ptrdiff_t bstride,vint8mf2_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8mf2(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse8_v_i8m1(int8_t* base,ptrdiff_t bstride,vint8m1_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8m1(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse8_v_i8m2(int8_t* base,ptrdiff_t bstride,vint8m2_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8m2(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse8_v_i8m4(int8_t* base,ptrdiff_t bstride,vint8m4_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8m4(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse8_v_i8m8(int8_t* base,ptrdiff_t bstride,vint8m8_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8m8(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse8_v_u8mf8(uint8_t* base,ptrdiff_t bstride,vuint8mf8_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8mf8(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse8_v_u8mf4(uint8_t* base,ptrdiff_t bstride,vuint8mf4_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8mf4(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse8_v_u8mf2(uint8_t* base,ptrdiff_t bstride,vuint8mf2_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8mf2(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse8_v_u8m1(uint8_t* base,ptrdiff_t bstride,vuint8m1_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8m1(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse8_v_u8m2(uint8_t* base,ptrdiff_t bstride,vuint8m2_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8m2(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse8_v_u8m4(uint8_t* base,ptrdiff_t bstride,vuint8m4_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8m4(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse8_v_u8m8(uint8_t* base,ptrdiff_t bstride,vuint8m8_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8m8(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse16_v_i16mf4(int16_t* base,ptrdiff_t bstride,vint16mf4_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16mf4(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse16_v_i16mf2(int16_t* base,ptrdiff_t bstride,vint16mf2_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16mf2(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse16_v_i16m1(int16_t* base,ptrdiff_t bstride,vint16m1_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16m1(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse16_v_i16m2(int16_t* base,ptrdiff_t bstride,vint16m2_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16m2(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse16_v_i16m4(int16_t* base,ptrdiff_t bstride,vint16m4_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16m4(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse16_v_i16m8(int16_t* base,ptrdiff_t bstride,vint16m8_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16m8(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse16_v_u16mf4(uint16_t* base,ptrdiff_t bstride,vuint16mf4_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16mf4(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse16_v_u16mf2(uint16_t* base,ptrdiff_t bstride,vuint16mf2_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16mf2(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse16_v_u16m1(uint16_t* base,ptrdiff_t bstride,vuint16m1_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16m1(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse16_v_u16m2(uint16_t* base,ptrdiff_t bstride,vuint16m2_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16m2(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse16_v_u16m4(uint16_t* base,ptrdiff_t bstride,vuint16m4_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16m4(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse16_v_u16m8(uint16_t* base,ptrdiff_t bstride,vuint16m8_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16m8(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse32_v_i32mf2(int32_t* base,ptrdiff_t bstride,vint32mf2_t value,size_t vl)
+{
+  __riscv_vsse32_v_i32mf2(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse32_v_i32m1(int32_t* base,ptrdiff_t bstride,vint32m1_t value,size_t vl)
+{
+  __riscv_vsse32_v_i32m1(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse32_v_i32m2(int32_t* base,ptrdiff_t bstride,vint32m2_t value,size_t vl)
+{
+  __riscv_vsse32_v_i32m2(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse32_v_i32m4(int32_t* base,ptrdiff_t bstride,vint32m4_t value,size_t vl)
+{
+  __riscv_vsse32_v_i32m4(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse32_v_i32m8(int32_t* base,ptrdiff_t bstride,vint32m8_t value,size_t vl)
+{
+  __riscv_vsse32_v_i32m8(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse32_v_u32mf2(uint32_t* base,ptrdiff_t bstride,vuint32mf2_t value,size_t vl)
+{
+  __riscv_vsse32_v_u32mf2(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse32_v_u32m1(uint32_t* base,ptrdiff_t bstride,vuint32m1_t value,size_t vl)
+{
+  __riscv_vsse32_v_u32m1(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse32_v_u32m2(uint32_t* base,ptrdiff_t bstride,vuint32m2_t value,size_t vl)
+{
+  __riscv_vsse32_v_u32m2(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse32_v_u32m4(uint32_t* base,ptrdiff_t bstride,vuint32m4_t value,size_t vl)
+{
+  __riscv_vsse32_v_u32m4(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse32_v_u32m8(uint32_t* base,ptrdiff_t bstride,vuint32m8_t value,size_t vl)
+{
+  __riscv_vsse32_v_u32m8(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse32_v_f32mf2(float* base,ptrdiff_t bstride,vfloat32mf2_t value,size_t vl)
+{
+  __riscv_vsse32_v_f32mf2(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse32_v_f32m1(float* base,ptrdiff_t bstride,vfloat32m1_t value,size_t vl)
+{
+  __riscv_vsse32_v_f32m1(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse32_v_f32m2(float* base,ptrdiff_t bstride,vfloat32m2_t value,size_t vl)
+{
+  __riscv_vsse32_v_f32m2(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse32_v_f32m4(float* base,ptrdiff_t bstride,vfloat32m4_t value,size_t vl)
+{
+  __riscv_vsse32_v_f32m4(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse32_v_f32m8(float* base,ptrdiff_t bstride,vfloat32m8_t value,size_t vl)
+{
+  __riscv_vsse32_v_f32m8(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse64_v_i64m1(int64_t* base,ptrdiff_t bstride,vint64m1_t value,size_t vl)
+{
+  __riscv_vsse64_v_i64m1(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse64_v_i64m2(int64_t* base,ptrdiff_t bstride,vint64m2_t value,size_t vl)
+{
+  __riscv_vsse64_v_i64m2(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse64_v_i64m4(int64_t* base,ptrdiff_t bstride,vint64m4_t value,size_t vl)
+{
+  __riscv_vsse64_v_i64m4(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse64_v_i64m8(int64_t* base,ptrdiff_t bstride,vint64m8_t value,size_t vl)
+{
+  __riscv_vsse64_v_i64m8(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse64_v_u64m1(uint64_t* base,ptrdiff_t bstride,vuint64m1_t value,size_t vl)
+{
+  __riscv_vsse64_v_u64m1(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse64_v_u64m2(uint64_t* base,ptrdiff_t bstride,vuint64m2_t value,size_t vl)
+{
+  __riscv_vsse64_v_u64m2(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse64_v_u64m4(uint64_t* base,ptrdiff_t bstride,vuint64m4_t value,size_t vl)
+{
+  __riscv_vsse64_v_u64m4(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse64_v_u64m8(uint64_t* base,ptrdiff_t bstride,vuint64m8_t value,size_t vl)
+{
+  __riscv_vsse64_v_u64m8(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse64_v_f64m1(double* base,ptrdiff_t bstride,vfloat64m1_t value,size_t vl)
+{
+  __riscv_vsse64_v_f64m1(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse64_v_f64m2(double* base,ptrdiff_t bstride,vfloat64m2_t value,size_t vl)
+{
+  __riscv_vsse64_v_f64m2(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse64_v_f64m4(double* base,ptrdiff_t bstride,vfloat64m4_t value,size_t vl)
+{
+  __riscv_vsse64_v_f64m4(base,bstride,value,31);
+}
+
+void
+test___riscv_vsse64_v_f64m8(double* base,ptrdiff_t bstride,vfloat64m8_t value,size_t vl)
+{
+  __riscv_vsse64_v_f64m8(base,bstride,value,31);
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsse64\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsse64\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsse64\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsse64\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsse-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsse-3.c
new file mode 100644
index 0000000..9c0d8a5
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsse-3.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void
+test___riscv_vsse8_v_i8mf8(int8_t* base,ptrdiff_t bstride,vint8mf8_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8mf8(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse8_v_i8mf4(int8_t* base,ptrdiff_t bstride,vint8mf4_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8mf4(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse8_v_i8mf2(int8_t* base,ptrdiff_t bstride,vint8mf2_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8mf2(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse8_v_i8m1(int8_t* base,ptrdiff_t bstride,vint8m1_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8m1(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse8_v_i8m2(int8_t* base,ptrdiff_t bstride,vint8m2_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8m2(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse8_v_i8m4(int8_t* base,ptrdiff_t bstride,vint8m4_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8m4(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse8_v_i8m8(int8_t* base,ptrdiff_t bstride,vint8m8_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8m8(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse8_v_u8mf8(uint8_t* base,ptrdiff_t bstride,vuint8mf8_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8mf8(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse8_v_u8mf4(uint8_t* base,ptrdiff_t bstride,vuint8mf4_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8mf4(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse8_v_u8mf2(uint8_t* base,ptrdiff_t bstride,vuint8mf2_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8mf2(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse8_v_u8m1(uint8_t* base,ptrdiff_t bstride,vuint8m1_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8m1(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse8_v_u8m2(uint8_t* base,ptrdiff_t bstride,vuint8m2_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8m2(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse8_v_u8m4(uint8_t* base,ptrdiff_t bstride,vuint8m4_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8m4(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse8_v_u8m8(uint8_t* base,ptrdiff_t bstride,vuint8m8_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8m8(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse16_v_i16mf4(int16_t* base,ptrdiff_t bstride,vint16mf4_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16mf4(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse16_v_i16mf2(int16_t* base,ptrdiff_t bstride,vint16mf2_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16mf2(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse16_v_i16m1(int16_t* base,ptrdiff_t bstride,vint16m1_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16m1(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse16_v_i16m2(int16_t* base,ptrdiff_t bstride,vint16m2_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16m2(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse16_v_i16m4(int16_t* base,ptrdiff_t bstride,vint16m4_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16m4(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse16_v_i16m8(int16_t* base,ptrdiff_t bstride,vint16m8_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16m8(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse16_v_u16mf4(uint16_t* base,ptrdiff_t bstride,vuint16mf4_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16mf4(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse16_v_u16mf2(uint16_t* base,ptrdiff_t bstride,vuint16mf2_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16mf2(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse16_v_u16m1(uint16_t* base,ptrdiff_t bstride,vuint16m1_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16m1(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse16_v_u16m2(uint16_t* base,ptrdiff_t bstride,vuint16m2_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16m2(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse16_v_u16m4(uint16_t* base,ptrdiff_t bstride,vuint16m4_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16m4(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse16_v_u16m8(uint16_t* base,ptrdiff_t bstride,vuint16m8_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16m8(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse32_v_i32mf2(int32_t* base,ptrdiff_t bstride,vint32mf2_t value,size_t vl)
+{
+  __riscv_vsse32_v_i32mf2(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse32_v_i32m1(int32_t* base,ptrdiff_t bstride,vint32m1_t value,size_t vl)
+{
+  __riscv_vsse32_v_i32m1(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse32_v_i32m2(int32_t* base,ptrdiff_t bstride,vint32m2_t value,size_t vl)
+{
+  __riscv_vsse32_v_i32m2(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse32_v_i32m4(int32_t* base,ptrdiff_t bstride,vint32m4_t value,size_t vl)
+{
+  __riscv_vsse32_v_i32m4(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse32_v_i32m8(int32_t* base,ptrdiff_t bstride,vint32m8_t value,size_t vl)
+{
+  __riscv_vsse32_v_i32m8(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse32_v_u32mf2(uint32_t* base,ptrdiff_t bstride,vuint32mf2_t value,size_t vl)
+{
+  __riscv_vsse32_v_u32mf2(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse32_v_u32m1(uint32_t* base,ptrdiff_t bstride,vuint32m1_t value,size_t vl)
+{
+  __riscv_vsse32_v_u32m1(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse32_v_u32m2(uint32_t* base,ptrdiff_t bstride,vuint32m2_t value,size_t vl)
+{
+  __riscv_vsse32_v_u32m2(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse32_v_u32m4(uint32_t* base,ptrdiff_t bstride,vuint32m4_t value,size_t vl)
+{
+  __riscv_vsse32_v_u32m4(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse32_v_u32m8(uint32_t* base,ptrdiff_t bstride,vuint32m8_t value,size_t vl)
+{
+  __riscv_vsse32_v_u32m8(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse32_v_f32mf2(float* base,ptrdiff_t bstride,vfloat32mf2_t value,size_t vl)
+{
+  __riscv_vsse32_v_f32mf2(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse32_v_f32m1(float* base,ptrdiff_t bstride,vfloat32m1_t value,size_t vl)
+{
+  __riscv_vsse32_v_f32m1(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse32_v_f32m2(float* base,ptrdiff_t bstride,vfloat32m2_t value,size_t vl)
+{
+  __riscv_vsse32_v_f32m2(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse32_v_f32m4(float* base,ptrdiff_t bstride,vfloat32m4_t value,size_t vl)
+{
+  __riscv_vsse32_v_f32m4(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse32_v_f32m8(float* base,ptrdiff_t bstride,vfloat32m8_t value,size_t vl)
+{
+  __riscv_vsse32_v_f32m8(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse64_v_i64m1(int64_t* base,ptrdiff_t bstride,vint64m1_t value,size_t vl)
+{
+  __riscv_vsse64_v_i64m1(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse64_v_i64m2(int64_t* base,ptrdiff_t bstride,vint64m2_t value,size_t vl)
+{
+  __riscv_vsse64_v_i64m2(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse64_v_i64m4(int64_t* base,ptrdiff_t bstride,vint64m4_t value,size_t vl)
+{
+  __riscv_vsse64_v_i64m4(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse64_v_i64m8(int64_t* base,ptrdiff_t bstride,vint64m8_t value,size_t vl)
+{
+  __riscv_vsse64_v_i64m8(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse64_v_u64m1(uint64_t* base,ptrdiff_t bstride,vuint64m1_t value,size_t vl)
+{
+  __riscv_vsse64_v_u64m1(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse64_v_u64m2(uint64_t* base,ptrdiff_t bstride,vuint64m2_t value,size_t vl)
+{
+  __riscv_vsse64_v_u64m2(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse64_v_u64m4(uint64_t* base,ptrdiff_t bstride,vuint64m4_t value,size_t vl)
+{
+  __riscv_vsse64_v_u64m4(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse64_v_u64m8(uint64_t* base,ptrdiff_t bstride,vuint64m8_t value,size_t vl)
+{
+  __riscv_vsse64_v_u64m8(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse64_v_f64m1(double* base,ptrdiff_t bstride,vfloat64m1_t value,size_t vl)
+{
+  __riscv_vsse64_v_f64m1(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse64_v_f64m2(double* base,ptrdiff_t bstride,vfloat64m2_t value,size_t vl)
+{
+  __riscv_vsse64_v_f64m2(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse64_v_f64m4(double* base,ptrdiff_t bstride,vfloat64m4_t value,size_t vl)
+{
+  __riscv_vsse64_v_f64m4(base,bstride,value,32);
+}
+
+void
+test___riscv_vsse64_v_f64m8(double* base,ptrdiff_t bstride,vfloat64m8_t value,size_t vl)
+{
+  __riscv_vsse64_v_f64m8(base,bstride,value,32);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsse64\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsse64\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsse64\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsse64\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+\s+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsse_m-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsse_m-1.c
new file mode 100644
index 0000000..daf625e
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsse_m-1.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void
+test___riscv_vsse8_v_i8mf8_m(vbool64_t mask,int8_t* base,ptrdiff_t bstride,vint8mf8_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8mf8_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_i8mf4_m(vbool32_t mask,int8_t* base,ptrdiff_t bstride,vint8mf4_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8mf4_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_i8mf2_m(vbool16_t mask,int8_t* base,ptrdiff_t bstride,vint8mf2_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8mf2_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_i8m1_m(vbool8_t mask,int8_t* base,ptrdiff_t bstride,vint8m1_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8m1_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_i8m2_m(vbool4_t mask,int8_t* base,ptrdiff_t bstride,vint8m2_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8m2_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_i8m4_m(vbool2_t mask,int8_t* base,ptrdiff_t bstride,vint8m4_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8m4_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_i8m8_m(vbool1_t mask,int8_t* base,ptrdiff_t bstride,vint8m8_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8m8_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_u8mf8_m(vbool64_t mask,uint8_t* base,ptrdiff_t bstride,vuint8mf8_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8mf8_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_u8mf4_m(vbool32_t mask,uint8_t* base,ptrdiff_t bstride,vuint8mf4_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8mf4_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_u8mf2_m(vbool16_t mask,uint8_t* base,ptrdiff_t bstride,vuint8mf2_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8mf2_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_u8m1_m(vbool8_t mask,uint8_t* base,ptrdiff_t bstride,vuint8m1_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8m1_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_u8m2_m(vbool4_t mask,uint8_t* base,ptrdiff_t bstride,vuint8m2_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8m2_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_u8m4_m(vbool2_t mask,uint8_t* base,ptrdiff_t bstride,vuint8m4_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8m4_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_u8m8_m(vbool1_t mask,uint8_t* base,ptrdiff_t bstride,vuint8m8_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8m8_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_i16mf4_m(vbool64_t mask,int16_t* base,ptrdiff_t bstride,vint16mf4_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16mf4_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_i16mf2_m(vbool32_t mask,int16_t* base,ptrdiff_t bstride,vint16mf2_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16mf2_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_i16m1_m(vbool16_t mask,int16_t* base,ptrdiff_t bstride,vint16m1_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16m1_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_i16m2_m(vbool8_t mask,int16_t* base,ptrdiff_t bstride,vint16m2_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16m2_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_i16m4_m(vbool4_t mask,int16_t* base,ptrdiff_t bstride,vint16m4_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16m4_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_i16m8_m(vbool2_t mask,int16_t* base,ptrdiff_t bstride,vint16m8_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16m8_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_u16mf4_m(vbool64_t mask,uint16_t* base,ptrdiff_t bstride,vuint16mf4_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16mf4_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_u16mf2_m(vbool32_t mask,uint16_t* base,ptrdiff_t bstride,vuint16mf2_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16mf2_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_u16m1_m(vbool16_t mask,uint16_t* base,ptrdiff_t bstride,vuint16m1_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16m1_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_u16m2_m(vbool8_t mask,uint16_t* base,ptrdiff_t bstride,vuint16m2_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16m2_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_u16m4_m(vbool4_t mask,uint16_t* base,ptrdiff_t bstride,vuint16m4_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16m4_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_u16m8_m(vbool2_t mask,uint16_t* base,ptrdiff_t bstride,vuint16m8_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16m8_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_i32mf2_m(vbool64_t mask,int32_t* base,ptrdiff_t bstride,vint32mf2_t value,size_t vl)
+{
+  __riscv_vsse32_v_i32mf2_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_i32m1_m(vbool32_t mask,int32_t* base,ptrdiff_t bstride,vint32m1_t value,size_t vl)
+{
+  __riscv_vsse32_v_i32m1_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_i32m2_m(vbool16_t mask,int32_t* base,ptrdiff_t bstride,vint32m2_t value,size_t vl)
+{
+  __riscv_vsse32_v_i32m2_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_i32m4_m(vbool8_t mask,int32_t* base,ptrdiff_t bstride,vint32m4_t value,size_t vl)
+{
+  __riscv_vsse32_v_i32m4_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_i32m8_m(vbool4_t mask,int32_t* base,ptrdiff_t bstride,vint32m8_t value,size_t vl)
+{
+  __riscv_vsse32_v_i32m8_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_u32mf2_m(vbool64_t mask,uint32_t* base,ptrdiff_t bstride,vuint32mf2_t value,size_t vl)
+{
+  __riscv_vsse32_v_u32mf2_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_u32m1_m(vbool32_t mask,uint32_t* base,ptrdiff_t bstride,vuint32m1_t value,size_t vl)
+{
+  __riscv_vsse32_v_u32m1_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_u32m2_m(vbool16_t mask,uint32_t* base,ptrdiff_t bstride,vuint32m2_t value,size_t vl)
+{
+  __riscv_vsse32_v_u32m2_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_u32m4_m(vbool8_t mask,uint32_t* base,ptrdiff_t bstride,vuint32m4_t value,size_t vl)
+{
+  __riscv_vsse32_v_u32m4_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_u32m8_m(vbool4_t mask,uint32_t* base,ptrdiff_t bstride,vuint32m8_t value,size_t vl)
+{
+  __riscv_vsse32_v_u32m8_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_f32mf2_m(vbool64_t mask,float* base,ptrdiff_t bstride,vfloat32mf2_t value,size_t vl)
+{
+  __riscv_vsse32_v_f32mf2_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_f32m1_m(vbool32_t mask,float* base,ptrdiff_t bstride,vfloat32m1_t value,size_t vl)
+{
+  __riscv_vsse32_v_f32m1_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_f32m2_m(vbool16_t mask,float* base,ptrdiff_t bstride,vfloat32m2_t value,size_t vl)
+{
+  __riscv_vsse32_v_f32m2_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_f32m4_m(vbool8_t mask,float* base,ptrdiff_t bstride,vfloat32m4_t value,size_t vl)
+{
+  __riscv_vsse32_v_f32m4_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_f32m8_m(vbool4_t mask,float* base,ptrdiff_t bstride,vfloat32m8_t value,size_t vl)
+{
+  __riscv_vsse32_v_f32m8_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_i64m1_m(vbool64_t mask,int64_t* base,ptrdiff_t bstride,vint64m1_t value,size_t vl)
+{
+  __riscv_vsse64_v_i64m1_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_i64m2_m(vbool32_t mask,int64_t* base,ptrdiff_t bstride,vint64m2_t value,size_t vl)
+{
+  __riscv_vsse64_v_i64m2_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_i64m4_m(vbool16_t mask,int64_t* base,ptrdiff_t bstride,vint64m4_t value,size_t vl)
+{
+  __riscv_vsse64_v_i64m4_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_i64m8_m(vbool8_t mask,int64_t* base,ptrdiff_t bstride,vint64m8_t value,size_t vl)
+{
+  __riscv_vsse64_v_i64m8_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_u64m1_m(vbool64_t mask,uint64_t* base,ptrdiff_t bstride,vuint64m1_t value,size_t vl)
+{
+  __riscv_vsse64_v_u64m1_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_u64m2_m(vbool32_t mask,uint64_t* base,ptrdiff_t bstride,vuint64m2_t value,size_t vl)
+{
+  __riscv_vsse64_v_u64m2_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_u64m4_m(vbool16_t mask,uint64_t* base,ptrdiff_t bstride,vuint64m4_t value,size_t vl)
+{
+  __riscv_vsse64_v_u64m4_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_u64m8_m(vbool8_t mask,uint64_t* base,ptrdiff_t bstride,vuint64m8_t value,size_t vl)
+{
+  __riscv_vsse64_v_u64m8_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_f64m1_m(vbool64_t mask,double* base,ptrdiff_t bstride,vfloat64m1_t value,size_t vl)
+{
+  __riscv_vsse64_v_f64m1_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_f64m2_m(vbool32_t mask,double* base,ptrdiff_t bstride,vfloat64m2_t value,size_t vl)
+{
+  __riscv_vsse64_v_f64m2_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_f64m4_m(vbool16_t mask,double* base,ptrdiff_t bstride,vfloat64m4_t value,size_t vl)
+{
+  __riscv_vsse64_v_f64m4_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_f64m8_m(vbool8_t mask,double* base,ptrdiff_t bstride,vfloat64m8_t value,size_t vl)
+{
+  __riscv_vsse64_v_f64m8_m(mask,base,bstride,value,vl);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsse64\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsse64\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsse64\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsse64\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsse_m-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsse_m-2.c
new file mode 100644
index 0000000..4ff35ff
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsse_m-2.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void
+test___riscv_vsse8_v_i8mf8_m(vbool64_t mask,int8_t* base,ptrdiff_t bstride,vint8mf8_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8mf8_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse8_v_i8mf4_m(vbool32_t mask,int8_t* base,ptrdiff_t bstride,vint8mf4_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8mf4_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse8_v_i8mf2_m(vbool16_t mask,int8_t* base,ptrdiff_t bstride,vint8mf2_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8mf2_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse8_v_i8m1_m(vbool8_t mask,int8_t* base,ptrdiff_t bstride,vint8m1_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8m1_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse8_v_i8m2_m(vbool4_t mask,int8_t* base,ptrdiff_t bstride,vint8m2_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8m2_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse8_v_i8m4_m(vbool2_t mask,int8_t* base,ptrdiff_t bstride,vint8m4_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8m4_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse8_v_i8m8_m(vbool1_t mask,int8_t* base,ptrdiff_t bstride,vint8m8_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8m8_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse8_v_u8mf8_m(vbool64_t mask,uint8_t* base,ptrdiff_t bstride,vuint8mf8_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8mf8_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse8_v_u8mf4_m(vbool32_t mask,uint8_t* base,ptrdiff_t bstride,vuint8mf4_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8mf4_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse8_v_u8mf2_m(vbool16_t mask,uint8_t* base,ptrdiff_t bstride,vuint8mf2_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8mf2_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse8_v_u8m1_m(vbool8_t mask,uint8_t* base,ptrdiff_t bstride,vuint8m1_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8m1_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse8_v_u8m2_m(vbool4_t mask,uint8_t* base,ptrdiff_t bstride,vuint8m2_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8m2_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse8_v_u8m4_m(vbool2_t mask,uint8_t* base,ptrdiff_t bstride,vuint8m4_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8m4_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse8_v_u8m8_m(vbool1_t mask,uint8_t* base,ptrdiff_t bstride,vuint8m8_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8m8_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse16_v_i16mf4_m(vbool64_t mask,int16_t* base,ptrdiff_t bstride,vint16mf4_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16mf4_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse16_v_i16mf2_m(vbool32_t mask,int16_t* base,ptrdiff_t bstride,vint16mf2_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16mf2_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse16_v_i16m1_m(vbool16_t mask,int16_t* base,ptrdiff_t bstride,vint16m1_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16m1_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse16_v_i16m2_m(vbool8_t mask,int16_t* base,ptrdiff_t bstride,vint16m2_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16m2_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse16_v_i16m4_m(vbool4_t mask,int16_t* base,ptrdiff_t bstride,vint16m4_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16m4_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse16_v_i16m8_m(vbool2_t mask,int16_t* base,ptrdiff_t bstride,vint16m8_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16m8_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse16_v_u16mf4_m(vbool64_t mask,uint16_t* base,ptrdiff_t bstride,vuint16mf4_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16mf4_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse16_v_u16mf2_m(vbool32_t mask,uint16_t* base,ptrdiff_t bstride,vuint16mf2_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16mf2_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse16_v_u16m1_m(vbool16_t mask,uint16_t* base,ptrdiff_t bstride,vuint16m1_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16m1_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse16_v_u16m2_m(vbool8_t mask,uint16_t* base,ptrdiff_t bstride,vuint16m2_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16m2_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse16_v_u16m4_m(vbool4_t mask,uint16_t* base,ptrdiff_t bstride,vuint16m4_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16m4_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse16_v_u16m8_m(vbool2_t mask,uint16_t* base,ptrdiff_t bstride,vuint16m8_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16m8_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse32_v_i32mf2_m(vbool64_t mask,int32_t* base,ptrdiff_t bstride,vint32mf2_t value,size_t vl)
+{
+  __riscv_vsse32_v_i32mf2_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse32_v_i32m1_m(vbool32_t mask,int32_t* base,ptrdiff_t bstride,vint32m1_t value,size_t vl)
+{
+  __riscv_vsse32_v_i32m1_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse32_v_i32m2_m(vbool16_t mask,int32_t* base,ptrdiff_t bstride,vint32m2_t value,size_t vl)
+{
+  __riscv_vsse32_v_i32m2_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse32_v_i32m4_m(vbool8_t mask,int32_t* base,ptrdiff_t bstride,vint32m4_t value,size_t vl)
+{
+  __riscv_vsse32_v_i32m4_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse32_v_i32m8_m(vbool4_t mask,int32_t* base,ptrdiff_t bstride,vint32m8_t value,size_t vl)
+{
+  __riscv_vsse32_v_i32m8_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse32_v_u32mf2_m(vbool64_t mask,uint32_t* base,ptrdiff_t bstride,vuint32mf2_t value,size_t vl)
+{
+  __riscv_vsse32_v_u32mf2_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse32_v_u32m1_m(vbool32_t mask,uint32_t* base,ptrdiff_t bstride,vuint32m1_t value,size_t vl)
+{
+  __riscv_vsse32_v_u32m1_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse32_v_u32m2_m(vbool16_t mask,uint32_t* base,ptrdiff_t bstride,vuint32m2_t value,size_t vl)
+{
+  __riscv_vsse32_v_u32m2_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse32_v_u32m4_m(vbool8_t mask,uint32_t* base,ptrdiff_t bstride,vuint32m4_t value,size_t vl)
+{
+  __riscv_vsse32_v_u32m4_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse32_v_u32m8_m(vbool4_t mask,uint32_t* base,ptrdiff_t bstride,vuint32m8_t value,size_t vl)
+{
+  __riscv_vsse32_v_u32m8_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse32_v_f32mf2_m(vbool64_t mask,float* base,ptrdiff_t bstride,vfloat32mf2_t value,size_t vl)
+{
+  __riscv_vsse32_v_f32mf2_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse32_v_f32m1_m(vbool32_t mask,float* base,ptrdiff_t bstride,vfloat32m1_t value,size_t vl)
+{
+  __riscv_vsse32_v_f32m1_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse32_v_f32m2_m(vbool16_t mask,float* base,ptrdiff_t bstride,vfloat32m2_t value,size_t vl)
+{
+  __riscv_vsse32_v_f32m2_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse32_v_f32m4_m(vbool8_t mask,float* base,ptrdiff_t bstride,vfloat32m4_t value,size_t vl)
+{
+  __riscv_vsse32_v_f32m4_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse32_v_f32m8_m(vbool4_t mask,float* base,ptrdiff_t bstride,vfloat32m8_t value,size_t vl)
+{
+  __riscv_vsse32_v_f32m8_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse64_v_i64m1_m(vbool64_t mask,int64_t* base,ptrdiff_t bstride,vint64m1_t value,size_t vl)
+{
+  __riscv_vsse64_v_i64m1_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse64_v_i64m2_m(vbool32_t mask,int64_t* base,ptrdiff_t bstride,vint64m2_t value,size_t vl)
+{
+  __riscv_vsse64_v_i64m2_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse64_v_i64m4_m(vbool16_t mask,int64_t* base,ptrdiff_t bstride,vint64m4_t value,size_t vl)
+{
+  __riscv_vsse64_v_i64m4_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse64_v_i64m8_m(vbool8_t mask,int64_t* base,ptrdiff_t bstride,vint64m8_t value,size_t vl)
+{
+  __riscv_vsse64_v_i64m8_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse64_v_u64m1_m(vbool64_t mask,uint64_t* base,ptrdiff_t bstride,vuint64m1_t value,size_t vl)
+{
+  __riscv_vsse64_v_u64m1_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse64_v_u64m2_m(vbool32_t mask,uint64_t* base,ptrdiff_t bstride,vuint64m2_t value,size_t vl)
+{
+  __riscv_vsse64_v_u64m2_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse64_v_u64m4_m(vbool16_t mask,uint64_t* base,ptrdiff_t bstride,vuint64m4_t value,size_t vl)
+{
+  __riscv_vsse64_v_u64m4_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse64_v_u64m8_m(vbool8_t mask,uint64_t* base,ptrdiff_t bstride,vuint64m8_t value,size_t vl)
+{
+  __riscv_vsse64_v_u64m8_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse64_v_f64m1_m(vbool64_t mask,double* base,ptrdiff_t bstride,vfloat64m1_t value,size_t vl)
+{
+  __riscv_vsse64_v_f64m1_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse64_v_f64m2_m(vbool32_t mask,double* base,ptrdiff_t bstride,vfloat64m2_t value,size_t vl)
+{
+  __riscv_vsse64_v_f64m2_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse64_v_f64m4_m(vbool16_t mask,double* base,ptrdiff_t bstride,vfloat64m4_t value,size_t vl)
+{
+  __riscv_vsse64_v_f64m4_m(mask,base,bstride,value,31);
+}
+
+void
+test___riscv_vsse64_v_f64m8_m(vbool8_t mask,double* base,ptrdiff_t bstride,vfloat64m8_t value,size_t vl)
+{
+  __riscv_vsse64_v_f64m8_m(mask,base,bstride,value,31);
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsse64\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsse64\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsse64\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsse64\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsse_m-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsse_m-3.c
new file mode 100644
index 0000000..daf625e
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsse_m-3.c
@@ -0,0 +1,345 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void
+test___riscv_vsse8_v_i8mf8_m(vbool64_t mask,int8_t* base,ptrdiff_t bstride,vint8mf8_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8mf8_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_i8mf4_m(vbool32_t mask,int8_t* base,ptrdiff_t bstride,vint8mf4_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8mf4_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_i8mf2_m(vbool16_t mask,int8_t* base,ptrdiff_t bstride,vint8mf2_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8mf2_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_i8m1_m(vbool8_t mask,int8_t* base,ptrdiff_t bstride,vint8m1_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8m1_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_i8m2_m(vbool4_t mask,int8_t* base,ptrdiff_t bstride,vint8m2_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8m2_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_i8m4_m(vbool2_t mask,int8_t* base,ptrdiff_t bstride,vint8m4_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8m4_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_i8m8_m(vbool1_t mask,int8_t* base,ptrdiff_t bstride,vint8m8_t value,size_t vl)
+{
+  __riscv_vsse8_v_i8m8_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_u8mf8_m(vbool64_t mask,uint8_t* base,ptrdiff_t bstride,vuint8mf8_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8mf8_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_u8mf4_m(vbool32_t mask,uint8_t* base,ptrdiff_t bstride,vuint8mf4_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8mf4_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_u8mf2_m(vbool16_t mask,uint8_t* base,ptrdiff_t bstride,vuint8mf2_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8mf2_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_u8m1_m(vbool8_t mask,uint8_t* base,ptrdiff_t bstride,vuint8m1_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8m1_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_u8m2_m(vbool4_t mask,uint8_t* base,ptrdiff_t bstride,vuint8m2_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8m2_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_u8m4_m(vbool2_t mask,uint8_t* base,ptrdiff_t bstride,vuint8m4_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8m4_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse8_v_u8m8_m(vbool1_t mask,uint8_t* base,ptrdiff_t bstride,vuint8m8_t value,size_t vl)
+{
+  __riscv_vsse8_v_u8m8_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_i16mf4_m(vbool64_t mask,int16_t* base,ptrdiff_t bstride,vint16mf4_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16mf4_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_i16mf2_m(vbool32_t mask,int16_t* base,ptrdiff_t bstride,vint16mf2_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16mf2_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_i16m1_m(vbool16_t mask,int16_t* base,ptrdiff_t bstride,vint16m1_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16m1_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_i16m2_m(vbool8_t mask,int16_t* base,ptrdiff_t bstride,vint16m2_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16m2_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_i16m4_m(vbool4_t mask,int16_t* base,ptrdiff_t bstride,vint16m4_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16m4_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_i16m8_m(vbool2_t mask,int16_t* base,ptrdiff_t bstride,vint16m8_t value,size_t vl)
+{
+  __riscv_vsse16_v_i16m8_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_u16mf4_m(vbool64_t mask,uint16_t* base,ptrdiff_t bstride,vuint16mf4_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16mf4_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_u16mf2_m(vbool32_t mask,uint16_t* base,ptrdiff_t bstride,vuint16mf2_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16mf2_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_u16m1_m(vbool16_t mask,uint16_t* base,ptrdiff_t bstride,vuint16m1_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16m1_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_u16m2_m(vbool8_t mask,uint16_t* base,ptrdiff_t bstride,vuint16m2_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16m2_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_u16m4_m(vbool4_t mask,uint16_t* base,ptrdiff_t bstride,vuint16m4_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16m4_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse16_v_u16m8_m(vbool2_t mask,uint16_t* base,ptrdiff_t bstride,vuint16m8_t value,size_t vl)
+{
+  __riscv_vsse16_v_u16m8_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_i32mf2_m(vbool64_t mask,int32_t* base,ptrdiff_t bstride,vint32mf2_t value,size_t vl)
+{
+  __riscv_vsse32_v_i32mf2_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_i32m1_m(vbool32_t mask,int32_t* base,ptrdiff_t bstride,vint32m1_t value,size_t vl)
+{
+  __riscv_vsse32_v_i32m1_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_i32m2_m(vbool16_t mask,int32_t* base,ptrdiff_t bstride,vint32m2_t value,size_t vl)
+{
+  __riscv_vsse32_v_i32m2_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_i32m4_m(vbool8_t mask,int32_t* base,ptrdiff_t bstride,vint32m4_t value,size_t vl)
+{
+  __riscv_vsse32_v_i32m4_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_i32m8_m(vbool4_t mask,int32_t* base,ptrdiff_t bstride,vint32m8_t value,size_t vl)
+{
+  __riscv_vsse32_v_i32m8_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_u32mf2_m(vbool64_t mask,uint32_t* base,ptrdiff_t bstride,vuint32mf2_t value,size_t vl)
+{
+  __riscv_vsse32_v_u32mf2_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_u32m1_m(vbool32_t mask,uint32_t* base,ptrdiff_t bstride,vuint32m1_t value,size_t vl)
+{
+  __riscv_vsse32_v_u32m1_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_u32m2_m(vbool16_t mask,uint32_t* base,ptrdiff_t bstride,vuint32m2_t value,size_t vl)
+{
+  __riscv_vsse32_v_u32m2_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_u32m4_m(vbool8_t mask,uint32_t* base,ptrdiff_t bstride,vuint32m4_t value,size_t vl)
+{
+  __riscv_vsse32_v_u32m4_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_u32m8_m(vbool4_t mask,uint32_t* base,ptrdiff_t bstride,vuint32m8_t value,size_t vl)
+{
+  __riscv_vsse32_v_u32m8_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_f32mf2_m(vbool64_t mask,float* base,ptrdiff_t bstride,vfloat32mf2_t value,size_t vl)
+{
+  __riscv_vsse32_v_f32mf2_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_f32m1_m(vbool32_t mask,float* base,ptrdiff_t bstride,vfloat32m1_t value,size_t vl)
+{
+  __riscv_vsse32_v_f32m1_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_f32m2_m(vbool16_t mask,float* base,ptrdiff_t bstride,vfloat32m2_t value,size_t vl)
+{
+  __riscv_vsse32_v_f32m2_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_f32m4_m(vbool8_t mask,float* base,ptrdiff_t bstride,vfloat32m4_t value,size_t vl)
+{
+  __riscv_vsse32_v_f32m4_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse32_v_f32m8_m(vbool4_t mask,float* base,ptrdiff_t bstride,vfloat32m8_t value,size_t vl)
+{
+  __riscv_vsse32_v_f32m8_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_i64m1_m(vbool64_t mask,int64_t* base,ptrdiff_t bstride,vint64m1_t value,size_t vl)
+{
+  __riscv_vsse64_v_i64m1_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_i64m2_m(vbool32_t mask,int64_t* base,ptrdiff_t bstride,vint64m2_t value,size_t vl)
+{
+  __riscv_vsse64_v_i64m2_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_i64m4_m(vbool16_t mask,int64_t* base,ptrdiff_t bstride,vint64m4_t value,size_t vl)
+{
+  __riscv_vsse64_v_i64m4_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_i64m8_m(vbool8_t mask,int64_t* base,ptrdiff_t bstride,vint64m8_t value,size_t vl)
+{
+  __riscv_vsse64_v_i64m8_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_u64m1_m(vbool64_t mask,uint64_t* base,ptrdiff_t bstride,vuint64m1_t value,size_t vl)
+{
+  __riscv_vsse64_v_u64m1_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_u64m2_m(vbool32_t mask,uint64_t* base,ptrdiff_t bstride,vuint64m2_t value,size_t vl)
+{
+  __riscv_vsse64_v_u64m2_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_u64m4_m(vbool16_t mask,uint64_t* base,ptrdiff_t bstride,vuint64m4_t value,size_t vl)
+{
+  __riscv_vsse64_v_u64m4_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_u64m8_m(vbool8_t mask,uint64_t* base,ptrdiff_t bstride,vuint64m8_t value,size_t vl)
+{
+  __riscv_vsse64_v_u64m8_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_f64m1_m(vbool64_t mask,double* base,ptrdiff_t bstride,vfloat64m1_t value,size_t vl)
+{
+  __riscv_vsse64_v_f64m1_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_f64m2_m(vbool32_t mask,double* base,ptrdiff_t bstride,vfloat64m2_t value,size_t vl)
+{
+  __riscv_vsse64_v_f64m2_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_f64m4_m(vbool16_t mask,double* base,ptrdiff_t bstride,vfloat64m4_t value,size_t vl)
+{
+  __riscv_vsse64_v_f64m4_m(mask,base,bstride,value,vl);
+}
+
+void
+test___riscv_vsse64_v_f64m8_m(vbool8_t mask,double* base,ptrdiff_t bstride,vfloat64m8_t value,size_t vl)
+{
+  __riscv_vsse64_v_f64m8_m(mask,base,bstride,value,vl);
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsse8\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsse16\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsse32\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsse64\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsse64\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsse64\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsse64\.v\s+v[0-9]+,0\s*\([a-x0-9]+\),\s*[a-x0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei16_v-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei16_v-1.c
new file mode 100644
index 0000000..25bd196
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei16_v-1.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei16_v_i8mf8(int8_t* base,vuint16mf4_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8mf8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i8mf4(int8_t* base,vuint16mf2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8mf4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i8mf2(int8_t* base,vuint16m1_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i8m1(int8_t* base,vuint16m2_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i8m2(int8_t* base,vuint16m4_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i8m4(int8_t* base,vuint16m8_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i16mf4(int16_t* base,vuint16mf4_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16mf4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i16mf2(int16_t* base,vuint16mf2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i16m1(int16_t* base,vuint16m1_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i16m2(int16_t* base,vuint16m2_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i16m4(int16_t* base,vuint16m4_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i16m8(int16_t* base,vuint16m8_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i32mf2(int32_t* base,vuint16mf4_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i32mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i32m1(int32_t* base,vuint16mf2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i32m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i32m2(int32_t* base,vuint16m1_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i32m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i32m4(int32_t* base,vuint16m2_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i32m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i32m8(int32_t* base,vuint16m4_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i32m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i64m1(int64_t* base,vuint16mf4_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i64m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i64m2(int64_t* base,vuint16mf2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i64m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i64m4(int64_t* base,vuint16m1_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i64m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i64m8(int64_t* base,vuint16m2_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i64m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u8mf8(uint8_t* base,vuint16mf4_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8mf8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u8mf4(uint8_t* base,vuint16mf2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8mf4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u8mf2(uint8_t* base,vuint16m1_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u8m1(uint8_t* base,vuint16m2_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u8m2(uint8_t* base,vuint16m4_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u8m4(uint8_t* base,vuint16m8_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u16mf4(uint16_t* base,vuint16mf4_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16mf4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u16mf2(uint16_t* base,vuint16mf2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u16m1(uint16_t* base,vuint16m1_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u16m2(uint16_t* base,vuint16m2_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u16m4(uint16_t* base,vuint16m4_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u16m8(uint16_t* base,vuint16m8_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u32mf2(uint32_t* base,vuint16mf4_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u32mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u32m1(uint32_t* base,vuint16mf2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u32m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u32m2(uint32_t* base,vuint16m1_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u32m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u32m4(uint32_t* base,vuint16m2_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u32m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u32m8(uint32_t* base,vuint16m4_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u32m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u64m1(uint64_t* base,vuint16mf4_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u64m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u64m2(uint64_t* base,vuint16mf2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u64m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u64m4(uint64_t* base,vuint16m1_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u64m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u64m8(uint64_t* base,vuint16m2_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u64m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_f32mf2(float* base,vuint16mf4_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f32mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_f32m1(float* base,vuint16mf2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f32m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_f32m2(float* base,vuint16m1_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f32m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_f32m4(float* base,vuint16m2_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f32m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_f32m8(float* base,vuint16m4_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f32m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_f64m1(double* base,vuint16mf4_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f64m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_f64m2(double* base,vuint16mf2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f64m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_f64m4(double* base,vuint16m1_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f64m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_f64m8(double* base,vuint16m2_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f64m8(base,bindex,value,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei16_v-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei16_v-2.c
new file mode 100644
index 0000000..07772c0
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei16_v-2.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei16_v_i8mf8(int8_t* base,vuint16mf4_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8mf8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i8mf4(int8_t* base,vuint16mf2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8mf4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i8mf2(int8_t* base,vuint16m1_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i8m1(int8_t* base,vuint16m2_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i8m2(int8_t* base,vuint16m4_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i8m4(int8_t* base,vuint16m8_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i16mf4(int16_t* base,vuint16mf4_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16mf4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i16mf2(int16_t* base,vuint16mf2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i16m1(int16_t* base,vuint16m1_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i16m2(int16_t* base,vuint16m2_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i16m4(int16_t* base,vuint16m4_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i16m8(int16_t* base,vuint16m8_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i32mf2(int32_t* base,vuint16mf4_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i32mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i32m1(int32_t* base,vuint16mf2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i32m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i32m2(int32_t* base,vuint16m1_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i32m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i32m4(int32_t* base,vuint16m2_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i32m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i32m8(int32_t* base,vuint16m4_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i32m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i64m1(int64_t* base,vuint16mf4_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i64m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i64m2(int64_t* base,vuint16mf2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i64m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i64m4(int64_t* base,vuint16m1_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i64m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i64m8(int64_t* base,vuint16m2_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i64m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u8mf8(uint8_t* base,vuint16mf4_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8mf8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u8mf4(uint8_t* base,vuint16mf2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8mf4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u8mf2(uint8_t* base,vuint16m1_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u8m1(uint8_t* base,vuint16m2_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u8m2(uint8_t* base,vuint16m4_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u8m4(uint8_t* base,vuint16m8_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u16mf4(uint16_t* base,vuint16mf4_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16mf4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u16mf2(uint16_t* base,vuint16mf2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u16m1(uint16_t* base,vuint16m1_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u16m2(uint16_t* base,vuint16m2_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u16m4(uint16_t* base,vuint16m4_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u16m8(uint16_t* base,vuint16m8_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u32mf2(uint32_t* base,vuint16mf4_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u32mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u32m1(uint32_t* base,vuint16mf2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u32m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u32m2(uint32_t* base,vuint16m1_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u32m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u32m4(uint32_t* base,vuint16m2_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u32m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u32m8(uint32_t* base,vuint16m4_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u32m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u64m1(uint64_t* base,vuint16mf4_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u64m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u64m2(uint64_t* base,vuint16mf2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u64m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u64m4(uint64_t* base,vuint16m1_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u64m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u64m8(uint64_t* base,vuint16m2_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u64m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_f32mf2(float* base,vuint16mf4_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f32mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_f32m1(float* base,vuint16mf2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f32m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_f32m2(float* base,vuint16m1_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f32m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_f32m4(float* base,vuint16m2_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f32m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_f32m8(float* base,vuint16m4_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f32m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_f64m1(double* base,vuint16mf4_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f64m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_f64m2(double* base,vuint16mf2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f64m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_f64m4(double* base,vuint16m1_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f64m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_f64m8(double* base,vuint16m2_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f64m8(base,bindex,value,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei16_v-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei16_v-3.c
new file mode 100644
index 0000000..575f3e7
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei16_v-3.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei16_v_i8mf8(int8_t* base,vuint16mf4_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8mf8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i8mf4(int8_t* base,vuint16mf2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8mf4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i8mf2(int8_t* base,vuint16m1_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i8m1(int8_t* base,vuint16m2_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i8m2(int8_t* base,vuint16m4_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i8m4(int8_t* base,vuint16m8_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i16mf4(int16_t* base,vuint16mf4_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16mf4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i16mf2(int16_t* base,vuint16mf2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i16m1(int16_t* base,vuint16m1_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i16m2(int16_t* base,vuint16m2_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i16m4(int16_t* base,vuint16m4_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i16m8(int16_t* base,vuint16m8_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i32mf2(int32_t* base,vuint16mf4_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i32mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i32m1(int32_t* base,vuint16mf2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i32m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i32m2(int32_t* base,vuint16m1_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i32m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i32m4(int32_t* base,vuint16m2_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i32m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i32m8(int32_t* base,vuint16m4_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i32m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i64m1(int64_t* base,vuint16mf4_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i64m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i64m2(int64_t* base,vuint16mf2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i64m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i64m4(int64_t* base,vuint16m1_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i64m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i64m8(int64_t* base,vuint16m2_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i64m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u8mf8(uint8_t* base,vuint16mf4_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8mf8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u8mf4(uint8_t* base,vuint16mf2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8mf4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u8mf2(uint8_t* base,vuint16m1_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u8m1(uint8_t* base,vuint16m2_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u8m2(uint8_t* base,vuint16m4_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u8m4(uint8_t* base,vuint16m8_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u16mf4(uint16_t* base,vuint16mf4_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16mf4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u16mf2(uint16_t* base,vuint16mf2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u16m1(uint16_t* base,vuint16m1_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u16m2(uint16_t* base,vuint16m2_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u16m4(uint16_t* base,vuint16m4_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u16m8(uint16_t* base,vuint16m8_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u32mf2(uint32_t* base,vuint16mf4_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u32mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u32m1(uint32_t* base,vuint16mf2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u32m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u32m2(uint32_t* base,vuint16m1_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u32m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u32m4(uint32_t* base,vuint16m2_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u32m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u32m8(uint32_t* base,vuint16m4_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u32m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u64m1(uint64_t* base,vuint16mf4_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u64m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u64m2(uint64_t* base,vuint16mf2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u64m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u64m4(uint64_t* base,vuint16m1_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u64m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u64m8(uint64_t* base,vuint16m2_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u64m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_f32mf2(float* base,vuint16mf4_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f32mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_f32m1(float* base,vuint16mf2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f32m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_f32m2(float* base,vuint16m1_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f32m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_f32m4(float* base,vuint16m2_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f32m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_f32m8(float* base,vuint16m4_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f32m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_f64m1(double* base,vuint16mf4_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f64m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_f64m2(double* base,vuint16mf2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f64m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_f64m4(double* base,vuint16m1_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f64m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_f64m8(double* base,vuint16m2_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f64m8(base,bindex,value,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei16_v_m-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei16_v_m-1.c
new file mode 100644
index 0000000..b727312
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei16_v_m-1.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei16_v_i8mf8_m(vbool64_t mask,int8_t* base,vuint16mf4_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8mf8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i8mf4_m(vbool32_t mask,int8_t* base,vuint16mf2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8mf4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i8mf2_m(vbool16_t mask,int8_t* base,vuint16m1_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i8m1_m(vbool8_t mask,int8_t* base,vuint16m2_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i8m2_m(vbool4_t mask,int8_t* base,vuint16m4_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i8m4_m(vbool2_t mask,int8_t* base,vuint16m8_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i16mf4_m(vbool64_t mask,int16_t* base,vuint16mf4_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16mf4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i16mf2_m(vbool32_t mask,int16_t* base,vuint16mf2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i16m1_m(vbool16_t mask,int16_t* base,vuint16m1_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i16m2_m(vbool8_t mask,int16_t* base,vuint16m2_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i16m4_m(vbool4_t mask,int16_t* base,vuint16m4_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i16m8_m(vbool2_t mask,int16_t* base,vuint16m8_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i32mf2_m(vbool64_t mask,int32_t* base,vuint16mf4_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i32mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i32m1_m(vbool32_t mask,int32_t* base,vuint16mf2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i32m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i32m2_m(vbool16_t mask,int32_t* base,vuint16m1_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i32m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i32m4_m(vbool8_t mask,int32_t* base,vuint16m2_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i32m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i32m8_m(vbool4_t mask,int32_t* base,vuint16m4_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i32m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i64m1_m(vbool64_t mask,int64_t* base,vuint16mf4_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i64m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i64m2_m(vbool32_t mask,int64_t* base,vuint16mf2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i64m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i64m4_m(vbool16_t mask,int64_t* base,vuint16m1_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i64m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_i64m8_m(vbool8_t mask,int64_t* base,vuint16m2_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i64m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u8mf8_m(vbool64_t mask,uint8_t* base,vuint16mf4_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8mf8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u8mf4_m(vbool32_t mask,uint8_t* base,vuint16mf2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8mf4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u8mf2_m(vbool16_t mask,uint8_t* base,vuint16m1_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u8m1_m(vbool8_t mask,uint8_t* base,vuint16m2_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u8m2_m(vbool4_t mask,uint8_t* base,vuint16m4_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u8m4_m(vbool2_t mask,uint8_t* base,vuint16m8_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u16mf4_m(vbool64_t mask,uint16_t* base,vuint16mf4_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16mf4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u16mf2_m(vbool32_t mask,uint16_t* base,vuint16mf2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u16m1_m(vbool16_t mask,uint16_t* base,vuint16m1_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u16m2_m(vbool8_t mask,uint16_t* base,vuint16m2_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u16m4_m(vbool4_t mask,uint16_t* base,vuint16m4_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u16m8_m(vbool2_t mask,uint16_t* base,vuint16m8_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u32mf2_m(vbool64_t mask,uint32_t* base,vuint16mf4_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u32mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u32m1_m(vbool32_t mask,uint32_t* base,vuint16mf2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u32m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u32m2_m(vbool16_t mask,uint32_t* base,vuint16m1_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u32m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u32m4_m(vbool8_t mask,uint32_t* base,vuint16m2_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u32m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u32m8_m(vbool4_t mask,uint32_t* base,vuint16m4_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u32m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u64m1_m(vbool64_t mask,uint64_t* base,vuint16mf4_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u64m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u64m2_m(vbool32_t mask,uint64_t* base,vuint16mf2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u64m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u64m4_m(vbool16_t mask,uint64_t* base,vuint16m1_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u64m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_u64m8_m(vbool8_t mask,uint64_t* base,vuint16m2_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u64m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_f32mf2_m(vbool64_t mask,float* base,vuint16mf4_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f32mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_f32m1_m(vbool32_t mask,float* base,vuint16mf2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f32m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_f32m2_m(vbool16_t mask,float* base,vuint16m1_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f32m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_f32m4_m(vbool8_t mask,float* base,vuint16m2_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f32m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_f32m8_m(vbool4_t mask,float* base,vuint16m4_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f32m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_f64m1_m(vbool64_t mask,double* base,vuint16mf4_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f64m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_f64m2_m(vbool32_t mask,double* base,vuint16mf2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f64m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_f64m4_m(vbool16_t mask,double* base,vuint16m1_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f64m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei16_v_f64m8_m(vbool8_t mask,double* base,vuint16m2_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f64m8_m(mask,base,bindex,value,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei16_v_m-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei16_v_m-2.c
new file mode 100644
index 0000000..53d506a
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei16_v_m-2.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei16_v_i8mf8_m(vbool64_t mask,int8_t* base,vuint16mf4_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8mf8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i8mf4_m(vbool32_t mask,int8_t* base,vuint16mf2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8mf4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i8mf2_m(vbool16_t mask,int8_t* base,vuint16m1_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i8m1_m(vbool8_t mask,int8_t* base,vuint16m2_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i8m2_m(vbool4_t mask,int8_t* base,vuint16m4_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i8m4_m(vbool2_t mask,int8_t* base,vuint16m8_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i16mf4_m(vbool64_t mask,int16_t* base,vuint16mf4_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16mf4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i16mf2_m(vbool32_t mask,int16_t* base,vuint16mf2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i16m1_m(vbool16_t mask,int16_t* base,vuint16m1_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i16m2_m(vbool8_t mask,int16_t* base,vuint16m2_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i16m4_m(vbool4_t mask,int16_t* base,vuint16m4_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i16m8_m(vbool2_t mask,int16_t* base,vuint16m8_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i32mf2_m(vbool64_t mask,int32_t* base,vuint16mf4_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i32mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i32m1_m(vbool32_t mask,int32_t* base,vuint16mf2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i32m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i32m2_m(vbool16_t mask,int32_t* base,vuint16m1_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i32m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i32m4_m(vbool8_t mask,int32_t* base,vuint16m2_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i32m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i32m8_m(vbool4_t mask,int32_t* base,vuint16m4_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i32m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i64m1_m(vbool64_t mask,int64_t* base,vuint16mf4_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i64m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i64m2_m(vbool32_t mask,int64_t* base,vuint16mf2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i64m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i64m4_m(vbool16_t mask,int64_t* base,vuint16m1_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i64m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_i64m8_m(vbool8_t mask,int64_t* base,vuint16m2_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i64m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u8mf8_m(vbool64_t mask,uint8_t* base,vuint16mf4_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8mf8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u8mf4_m(vbool32_t mask,uint8_t* base,vuint16mf2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8mf4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u8mf2_m(vbool16_t mask,uint8_t* base,vuint16m1_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u8m1_m(vbool8_t mask,uint8_t* base,vuint16m2_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u8m2_m(vbool4_t mask,uint8_t* base,vuint16m4_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u8m4_m(vbool2_t mask,uint8_t* base,vuint16m8_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u16mf4_m(vbool64_t mask,uint16_t* base,vuint16mf4_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16mf4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u16mf2_m(vbool32_t mask,uint16_t* base,vuint16mf2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u16m1_m(vbool16_t mask,uint16_t* base,vuint16m1_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u16m2_m(vbool8_t mask,uint16_t* base,vuint16m2_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u16m4_m(vbool4_t mask,uint16_t* base,vuint16m4_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u16m8_m(vbool2_t mask,uint16_t* base,vuint16m8_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u32mf2_m(vbool64_t mask,uint32_t* base,vuint16mf4_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u32mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u32m1_m(vbool32_t mask,uint32_t* base,vuint16mf2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u32m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u32m2_m(vbool16_t mask,uint32_t* base,vuint16m1_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u32m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u32m4_m(vbool8_t mask,uint32_t* base,vuint16m2_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u32m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u32m8_m(vbool4_t mask,uint32_t* base,vuint16m4_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u32m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u64m1_m(vbool64_t mask,uint64_t* base,vuint16mf4_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u64m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u64m2_m(vbool32_t mask,uint64_t* base,vuint16mf2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u64m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u64m4_m(vbool16_t mask,uint64_t* base,vuint16m1_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u64m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_u64m8_m(vbool8_t mask,uint64_t* base,vuint16m2_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u64m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_f32mf2_m(vbool64_t mask,float* base,vuint16mf4_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f32mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_f32m1_m(vbool32_t mask,float* base,vuint16mf2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f32m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_f32m2_m(vbool16_t mask,float* base,vuint16m1_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f32m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_f32m4_m(vbool8_t mask,float* base,vuint16m2_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f32m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_f32m8_m(vbool4_t mask,float* base,vuint16m4_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f32m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_f64m1_m(vbool64_t mask,double* base,vuint16mf4_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f64m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_f64m2_m(vbool32_t mask,double* base,vuint16mf2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f64m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_f64m4_m(vbool16_t mask,double* base,vuint16m1_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f64m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei16_v_f64m8_m(vbool8_t mask,double* base,vuint16m2_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f64m8_m(mask,base,bindex,value,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei16_v_m-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei16_v_m-3.c
new file mode 100644
index 0000000..54e5c59
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei16_v_m-3.c
@@ -0,0 +1,333 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei16_v_i8mf8_m(vbool64_t mask,int8_t* base,vuint16mf4_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8mf8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i8mf4_m(vbool32_t mask,int8_t* base,vuint16mf2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8mf4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i8mf2_m(vbool16_t mask,int8_t* base,vuint16m1_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i8m1_m(vbool8_t mask,int8_t* base,vuint16m2_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i8m2_m(vbool4_t mask,int8_t* base,vuint16m4_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i8m4_m(vbool2_t mask,int8_t* base,vuint16m8_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i8m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i16mf4_m(vbool64_t mask,int16_t* base,vuint16mf4_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16mf4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i16mf2_m(vbool32_t mask,int16_t* base,vuint16mf2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i16m1_m(vbool16_t mask,int16_t* base,vuint16m1_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i16m2_m(vbool8_t mask,int16_t* base,vuint16m2_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i16m4_m(vbool4_t mask,int16_t* base,vuint16m4_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i16m8_m(vbool2_t mask,int16_t* base,vuint16m8_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i16m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i32mf2_m(vbool64_t mask,int32_t* base,vuint16mf4_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i32mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i32m1_m(vbool32_t mask,int32_t* base,vuint16mf2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i32m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i32m2_m(vbool16_t mask,int32_t* base,vuint16m1_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i32m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i32m4_m(vbool8_t mask,int32_t* base,vuint16m2_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i32m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i32m8_m(vbool4_t mask,int32_t* base,vuint16m4_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i32m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i64m1_m(vbool64_t mask,int64_t* base,vuint16mf4_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i64m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i64m2_m(vbool32_t mask,int64_t* base,vuint16mf2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i64m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i64m4_m(vbool16_t mask,int64_t* base,vuint16m1_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i64m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_i64m8_m(vbool8_t mask,int64_t* base,vuint16m2_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_i64m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u8mf8_m(vbool64_t mask,uint8_t* base,vuint16mf4_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8mf8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u8mf4_m(vbool32_t mask,uint8_t* base,vuint16mf2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8mf4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u8mf2_m(vbool16_t mask,uint8_t* base,vuint16m1_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u8m1_m(vbool8_t mask,uint8_t* base,vuint16m2_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u8m2_m(vbool4_t mask,uint8_t* base,vuint16m4_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u8m4_m(vbool2_t mask,uint8_t* base,vuint16m8_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u8m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u16mf4_m(vbool64_t mask,uint16_t* base,vuint16mf4_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16mf4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u16mf2_m(vbool32_t mask,uint16_t* base,vuint16mf2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u16m1_m(vbool16_t mask,uint16_t* base,vuint16m1_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u16m2_m(vbool8_t mask,uint16_t* base,vuint16m2_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u16m4_m(vbool4_t mask,uint16_t* base,vuint16m4_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u16m8_m(vbool2_t mask,uint16_t* base,vuint16m8_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u16m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u32mf2_m(vbool64_t mask,uint32_t* base,vuint16mf4_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u32mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u32m1_m(vbool32_t mask,uint32_t* base,vuint16mf2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u32m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u32m2_m(vbool16_t mask,uint32_t* base,vuint16m1_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u32m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u32m4_m(vbool8_t mask,uint32_t* base,vuint16m2_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u32m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u32m8_m(vbool4_t mask,uint32_t* base,vuint16m4_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u32m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u64m1_m(vbool64_t mask,uint64_t* base,vuint16mf4_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u64m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u64m2_m(vbool32_t mask,uint64_t* base,vuint16mf2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u64m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u64m4_m(vbool16_t mask,uint64_t* base,vuint16m1_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u64m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_u64m8_m(vbool8_t mask,uint64_t* base,vuint16m2_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_u64m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_f32mf2_m(vbool64_t mask,float* base,vuint16mf4_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f32mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_f32m1_m(vbool32_t mask,float* base,vuint16mf2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f32m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_f32m2_m(vbool16_t mask,float* base,vuint16m1_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f32m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_f32m4_m(vbool8_t mask,float* base,vuint16m2_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f32m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_f32m8_m(vbool4_t mask,float* base,vuint16m4_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f32m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_f64m1_m(vbool64_t mask,double* base,vuint16mf4_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f64m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_f64m2_m(vbool32_t mask,double* base,vuint16mf2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f64m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_f64m4_m(vbool16_t mask,double* base,vuint16m1_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f64m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei16_v_f64m8_m(vbool8_t mask,double* base,vuint16m2_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei16_v_f64m8_m(mask,base,bindex,value,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei16\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei32_v-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei32_v-1.c
new file mode 100644
index 0000000..269c5a6
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei32_v-1.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei32_v_i8mf8(int8_t* base,vuint32mf2_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i8mf8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i8mf4(int8_t* base,vuint32m1_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i8mf4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i8mf2(int8_t* base,vuint32m2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i8mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i8m1(int8_t* base,vuint32m4_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i8m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i8m2(int8_t* base,vuint32m8_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i8m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i16mf4(int16_t* base,vuint32mf2_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i16mf4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i16mf2(int16_t* base,vuint32m1_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i16mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i16m1(int16_t* base,vuint32m2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i16m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i16m2(int16_t* base,vuint32m4_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i16m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i16m4(int16_t* base,vuint32m8_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i16m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i32mf2(int32_t* base,vuint32mf2_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i32mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i32m1(int32_t* base,vuint32m1_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i32m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i32m2(int32_t* base,vuint32m2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i32m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i32m4(int32_t* base,vuint32m4_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i32m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i32m8(int32_t* base,vuint32m8_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i32m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i64m1(int64_t* base,vuint32mf2_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i64m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i64m2(int64_t* base,vuint32m1_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i64m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i64m4(int64_t* base,vuint32m2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i64m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i64m8(int64_t* base,vuint32m4_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i64m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u8mf8(uint8_t* base,vuint32mf2_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u8mf8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u8mf4(uint8_t* base,vuint32m1_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u8mf4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u8mf2(uint8_t* base,vuint32m2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u8mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u8m1(uint8_t* base,vuint32m4_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u8m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u8m2(uint8_t* base,vuint32m8_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u8m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u16mf4(uint16_t* base,vuint32mf2_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u16mf4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u16mf2(uint16_t* base,vuint32m1_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u16mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u16m1(uint16_t* base,vuint32m2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u16m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u16m2(uint16_t* base,vuint32m4_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u16m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u16m4(uint16_t* base,vuint32m8_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u16m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u32mf2(uint32_t* base,vuint32mf2_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u32mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u32m1(uint32_t* base,vuint32m1_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u32m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u32m2(uint32_t* base,vuint32m2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u32m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u32m4(uint32_t* base,vuint32m4_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u32m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u32m8(uint32_t* base,vuint32m8_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u32m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u64m1(uint64_t* base,vuint32mf2_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u64m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u64m2(uint64_t* base,vuint32m1_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u64m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u64m4(uint64_t* base,vuint32m2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u64m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u64m8(uint64_t* base,vuint32m4_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u64m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_f32mf2(float* base,vuint32mf2_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f32mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_f32m1(float* base,vuint32m1_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f32m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_f32m2(float* base,vuint32m2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f32m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_f32m4(float* base,vuint32m4_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f32m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_f32m8(float* base,vuint32m8_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f32m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_f64m1(double* base,vuint32mf2_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f64m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_f64m2(double* base,vuint32m1_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f64m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_f64m4(double* base,vuint32m2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f64m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_f64m8(double* base,vuint32m4_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f64m8(base,bindex,value,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei32_v-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei32_v-2.c
new file mode 100644
index 0000000..eae7dd8
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei32_v-2.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei32_v_i8mf8(int8_t* base,vuint32mf2_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i8mf8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i8mf4(int8_t* base,vuint32m1_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i8mf4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i8mf2(int8_t* base,vuint32m2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i8mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i8m1(int8_t* base,vuint32m4_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i8m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i8m2(int8_t* base,vuint32m8_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i8m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i16mf4(int16_t* base,vuint32mf2_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i16mf4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i16mf2(int16_t* base,vuint32m1_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i16mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i16m1(int16_t* base,vuint32m2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i16m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i16m2(int16_t* base,vuint32m4_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i16m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i16m4(int16_t* base,vuint32m8_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i16m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i32mf2(int32_t* base,vuint32mf2_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i32mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i32m1(int32_t* base,vuint32m1_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i32m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i32m2(int32_t* base,vuint32m2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i32m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i32m4(int32_t* base,vuint32m4_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i32m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i32m8(int32_t* base,vuint32m8_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i32m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i64m1(int64_t* base,vuint32mf2_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i64m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i64m2(int64_t* base,vuint32m1_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i64m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i64m4(int64_t* base,vuint32m2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i64m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i64m8(int64_t* base,vuint32m4_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i64m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u8mf8(uint8_t* base,vuint32mf2_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u8mf8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u8mf4(uint8_t* base,vuint32m1_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u8mf4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u8mf2(uint8_t* base,vuint32m2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u8mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u8m1(uint8_t* base,vuint32m4_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u8m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u8m2(uint8_t* base,vuint32m8_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u8m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u16mf4(uint16_t* base,vuint32mf2_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u16mf4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u16mf2(uint16_t* base,vuint32m1_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u16mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u16m1(uint16_t* base,vuint32m2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u16m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u16m2(uint16_t* base,vuint32m4_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u16m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u16m4(uint16_t* base,vuint32m8_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u16m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u32mf2(uint32_t* base,vuint32mf2_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u32mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u32m1(uint32_t* base,vuint32m1_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u32m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u32m2(uint32_t* base,vuint32m2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u32m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u32m4(uint32_t* base,vuint32m4_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u32m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u32m8(uint32_t* base,vuint32m8_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u32m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u64m1(uint64_t* base,vuint32mf2_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u64m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u64m2(uint64_t* base,vuint32m1_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u64m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u64m4(uint64_t* base,vuint32m2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u64m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u64m8(uint64_t* base,vuint32m4_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u64m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_f32mf2(float* base,vuint32mf2_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f32mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_f32m1(float* base,vuint32m1_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f32m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_f32m2(float* base,vuint32m2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f32m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_f32m4(float* base,vuint32m4_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f32m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_f32m8(float* base,vuint32m8_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f32m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_f64m1(double* base,vuint32mf2_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f64m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_f64m2(double* base,vuint32m1_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f64m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_f64m4(double* base,vuint32m2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f64m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_f64m8(double* base,vuint32m4_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f64m8(base,bindex,value,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei32_v-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei32_v-3.c
new file mode 100644
index 0000000..89a7377
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei32_v-3.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei32_v_i8mf8(int8_t* base,vuint32mf2_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i8mf8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i8mf4(int8_t* base,vuint32m1_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i8mf4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i8mf2(int8_t* base,vuint32m2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i8mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i8m1(int8_t* base,vuint32m4_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i8m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i8m2(int8_t* base,vuint32m8_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i8m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i16mf4(int16_t* base,vuint32mf2_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i16mf4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i16mf2(int16_t* base,vuint32m1_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i16mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i16m1(int16_t* base,vuint32m2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i16m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i16m2(int16_t* base,vuint32m4_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i16m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i16m4(int16_t* base,vuint32m8_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i16m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i32mf2(int32_t* base,vuint32mf2_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i32mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i32m1(int32_t* base,vuint32m1_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i32m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i32m2(int32_t* base,vuint32m2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i32m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i32m4(int32_t* base,vuint32m4_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i32m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i32m8(int32_t* base,vuint32m8_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i32m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i64m1(int64_t* base,vuint32mf2_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i64m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i64m2(int64_t* base,vuint32m1_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i64m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i64m4(int64_t* base,vuint32m2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i64m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i64m8(int64_t* base,vuint32m4_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i64m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u8mf8(uint8_t* base,vuint32mf2_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u8mf8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u8mf4(uint8_t* base,vuint32m1_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u8mf4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u8mf2(uint8_t* base,vuint32m2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u8mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u8m1(uint8_t* base,vuint32m4_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u8m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u8m2(uint8_t* base,vuint32m8_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u8m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u16mf4(uint16_t* base,vuint32mf2_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u16mf4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u16mf2(uint16_t* base,vuint32m1_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u16mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u16m1(uint16_t* base,vuint32m2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u16m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u16m2(uint16_t* base,vuint32m4_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u16m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u16m4(uint16_t* base,vuint32m8_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u16m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u32mf2(uint32_t* base,vuint32mf2_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u32mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u32m1(uint32_t* base,vuint32m1_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u32m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u32m2(uint32_t* base,vuint32m2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u32m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u32m4(uint32_t* base,vuint32m4_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u32m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u32m8(uint32_t* base,vuint32m8_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u32m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u64m1(uint64_t* base,vuint32mf2_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u64m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u64m2(uint64_t* base,vuint32m1_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u64m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u64m4(uint64_t* base,vuint32m2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u64m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u64m8(uint64_t* base,vuint32m4_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u64m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_f32mf2(float* base,vuint32mf2_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f32mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_f32m1(float* base,vuint32m1_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f32m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_f32m2(float* base,vuint32m2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f32m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_f32m4(float* base,vuint32m4_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f32m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_f32m8(float* base,vuint32m8_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f32m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_f64m1(double* base,vuint32mf2_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f64m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_f64m2(double* base,vuint32m1_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f64m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_f64m4(double* base,vuint32m2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f64m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_f64m8(double* base,vuint32m4_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f64m8(base,bindex,value,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei32_v_m-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei32_v_m-1.c
new file mode 100644
index 0000000..0fb4024
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei32_v_m-1.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei32_v_i8mf8_m(vbool64_t mask,int8_t* base,vuint32mf2_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i8mf8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i8mf4_m(vbool32_t mask,int8_t* base,vuint32m1_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i8mf4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i8mf2_m(vbool16_t mask,int8_t* base,vuint32m2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i8mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i8m1_m(vbool8_t mask,int8_t* base,vuint32m4_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i8m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i8m2_m(vbool4_t mask,int8_t* base,vuint32m8_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i8m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i16mf4_m(vbool64_t mask,int16_t* base,vuint32mf2_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i16mf4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i16mf2_m(vbool32_t mask,int16_t* base,vuint32m1_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i16mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i16m1_m(vbool16_t mask,int16_t* base,vuint32m2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i16m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i16m2_m(vbool8_t mask,int16_t* base,vuint32m4_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i16m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i16m4_m(vbool4_t mask,int16_t* base,vuint32m8_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i16m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i32mf2_m(vbool64_t mask,int32_t* base,vuint32mf2_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i32mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i32m1_m(vbool32_t mask,int32_t* base,vuint32m1_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i32m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i32m2_m(vbool16_t mask,int32_t* base,vuint32m2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i32m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i32m4_m(vbool8_t mask,int32_t* base,vuint32m4_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i32m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i32m8_m(vbool4_t mask,int32_t* base,vuint32m8_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i32m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i64m1_m(vbool64_t mask,int64_t* base,vuint32mf2_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i64m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i64m2_m(vbool32_t mask,int64_t* base,vuint32m1_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i64m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i64m4_m(vbool16_t mask,int64_t* base,vuint32m2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i64m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_i64m8_m(vbool8_t mask,int64_t* base,vuint32m4_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i64m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u8mf8_m(vbool64_t mask,uint8_t* base,vuint32mf2_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u8mf8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u8mf4_m(vbool32_t mask,uint8_t* base,vuint32m1_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u8mf4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u8mf2_m(vbool16_t mask,uint8_t* base,vuint32m2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u8mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u8m1_m(vbool8_t mask,uint8_t* base,vuint32m4_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u8m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u8m2_m(vbool4_t mask,uint8_t* base,vuint32m8_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u8m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u16mf4_m(vbool64_t mask,uint16_t* base,vuint32mf2_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u16mf4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u16mf2_m(vbool32_t mask,uint16_t* base,vuint32m1_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u16mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u16m1_m(vbool16_t mask,uint16_t* base,vuint32m2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u16m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u16m2_m(vbool8_t mask,uint16_t* base,vuint32m4_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u16m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u16m4_m(vbool4_t mask,uint16_t* base,vuint32m8_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u16m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u32mf2_m(vbool64_t mask,uint32_t* base,vuint32mf2_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u32mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u32m1_m(vbool32_t mask,uint32_t* base,vuint32m1_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u32m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u32m2_m(vbool16_t mask,uint32_t* base,vuint32m2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u32m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u32m4_m(vbool8_t mask,uint32_t* base,vuint32m4_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u32m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u32m8_m(vbool4_t mask,uint32_t* base,vuint32m8_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u32m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u64m1_m(vbool64_t mask,uint64_t* base,vuint32mf2_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u64m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u64m2_m(vbool32_t mask,uint64_t* base,vuint32m1_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u64m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u64m4_m(vbool16_t mask,uint64_t* base,vuint32m2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u64m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_u64m8_m(vbool8_t mask,uint64_t* base,vuint32m4_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u64m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_f32mf2_m(vbool64_t mask,float* base,vuint32mf2_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f32mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_f32m1_m(vbool32_t mask,float* base,vuint32m1_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f32m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_f32m2_m(vbool16_t mask,float* base,vuint32m2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f32m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_f32m4_m(vbool8_t mask,float* base,vuint32m4_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f32m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_f32m8_m(vbool4_t mask,float* base,vuint32m8_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f32m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_f64m1_m(vbool64_t mask,double* base,vuint32mf2_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f64m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_f64m2_m(vbool32_t mask,double* base,vuint32m1_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f64m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_f64m4_m(vbool16_t mask,double* base,vuint32m2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f64m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei32_v_f64m8_m(vbool8_t mask,double* base,vuint32m4_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f64m8_m(mask,base,bindex,value,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei32_v_m-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei32_v_m-2.c
new file mode 100644
index 0000000..d7c0c93
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei32_v_m-2.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei32_v_i8mf8_m(vbool64_t mask,int8_t* base,vuint32mf2_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i8mf8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i8mf4_m(vbool32_t mask,int8_t* base,vuint32m1_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i8mf4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i8mf2_m(vbool16_t mask,int8_t* base,vuint32m2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i8mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i8m1_m(vbool8_t mask,int8_t* base,vuint32m4_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i8m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i8m2_m(vbool4_t mask,int8_t* base,vuint32m8_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i8m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i16mf4_m(vbool64_t mask,int16_t* base,vuint32mf2_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i16mf4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i16mf2_m(vbool32_t mask,int16_t* base,vuint32m1_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i16mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i16m1_m(vbool16_t mask,int16_t* base,vuint32m2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i16m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i16m2_m(vbool8_t mask,int16_t* base,vuint32m4_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i16m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i16m4_m(vbool4_t mask,int16_t* base,vuint32m8_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i16m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i32mf2_m(vbool64_t mask,int32_t* base,vuint32mf2_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i32mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i32m1_m(vbool32_t mask,int32_t* base,vuint32m1_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i32m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i32m2_m(vbool16_t mask,int32_t* base,vuint32m2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i32m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i32m4_m(vbool8_t mask,int32_t* base,vuint32m4_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i32m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i32m8_m(vbool4_t mask,int32_t* base,vuint32m8_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i32m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i64m1_m(vbool64_t mask,int64_t* base,vuint32mf2_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i64m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i64m2_m(vbool32_t mask,int64_t* base,vuint32m1_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i64m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i64m4_m(vbool16_t mask,int64_t* base,vuint32m2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i64m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_i64m8_m(vbool8_t mask,int64_t* base,vuint32m4_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i64m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u8mf8_m(vbool64_t mask,uint8_t* base,vuint32mf2_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u8mf8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u8mf4_m(vbool32_t mask,uint8_t* base,vuint32m1_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u8mf4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u8mf2_m(vbool16_t mask,uint8_t* base,vuint32m2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u8mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u8m1_m(vbool8_t mask,uint8_t* base,vuint32m4_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u8m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u8m2_m(vbool4_t mask,uint8_t* base,vuint32m8_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u8m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u16mf4_m(vbool64_t mask,uint16_t* base,vuint32mf2_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u16mf4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u16mf2_m(vbool32_t mask,uint16_t* base,vuint32m1_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u16mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u16m1_m(vbool16_t mask,uint16_t* base,vuint32m2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u16m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u16m2_m(vbool8_t mask,uint16_t* base,vuint32m4_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u16m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u16m4_m(vbool4_t mask,uint16_t* base,vuint32m8_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u16m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u32mf2_m(vbool64_t mask,uint32_t* base,vuint32mf2_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u32mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u32m1_m(vbool32_t mask,uint32_t* base,vuint32m1_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u32m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u32m2_m(vbool16_t mask,uint32_t* base,vuint32m2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u32m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u32m4_m(vbool8_t mask,uint32_t* base,vuint32m4_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u32m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u32m8_m(vbool4_t mask,uint32_t* base,vuint32m8_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u32m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u64m1_m(vbool64_t mask,uint64_t* base,vuint32mf2_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u64m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u64m2_m(vbool32_t mask,uint64_t* base,vuint32m1_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u64m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u64m4_m(vbool16_t mask,uint64_t* base,vuint32m2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u64m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_u64m8_m(vbool8_t mask,uint64_t* base,vuint32m4_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u64m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_f32mf2_m(vbool64_t mask,float* base,vuint32mf2_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f32mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_f32m1_m(vbool32_t mask,float* base,vuint32m1_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f32m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_f32m2_m(vbool16_t mask,float* base,vuint32m2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f32m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_f32m4_m(vbool8_t mask,float* base,vuint32m4_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f32m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_f32m8_m(vbool4_t mask,float* base,vuint32m8_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f32m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_f64m1_m(vbool64_t mask,double* base,vuint32mf2_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f64m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_f64m2_m(vbool32_t mask,double* base,vuint32m1_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f64m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_f64m4_m(vbool16_t mask,double* base,vuint32m2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f64m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei32_v_f64m8_m(vbool8_t mask,double* base,vuint32m4_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f64m8_m(mask,base,bindex,value,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei32_v_m-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei32_v_m-3.c
new file mode 100644
index 0000000..4bf1210
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei32_v_m-3.c
@@ -0,0 +1,307 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei32_v_i8mf8_m(vbool64_t mask,int8_t* base,vuint32mf2_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i8mf8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i8mf4_m(vbool32_t mask,int8_t* base,vuint32m1_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i8mf4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i8mf2_m(vbool16_t mask,int8_t* base,vuint32m2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i8mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i8m1_m(vbool8_t mask,int8_t* base,vuint32m4_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i8m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i8m2_m(vbool4_t mask,int8_t* base,vuint32m8_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i8m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i16mf4_m(vbool64_t mask,int16_t* base,vuint32mf2_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i16mf4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i16mf2_m(vbool32_t mask,int16_t* base,vuint32m1_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i16mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i16m1_m(vbool16_t mask,int16_t* base,vuint32m2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i16m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i16m2_m(vbool8_t mask,int16_t* base,vuint32m4_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i16m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i16m4_m(vbool4_t mask,int16_t* base,vuint32m8_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i16m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i32mf2_m(vbool64_t mask,int32_t* base,vuint32mf2_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i32mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i32m1_m(vbool32_t mask,int32_t* base,vuint32m1_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i32m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i32m2_m(vbool16_t mask,int32_t* base,vuint32m2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i32m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i32m4_m(vbool8_t mask,int32_t* base,vuint32m4_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i32m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i32m8_m(vbool4_t mask,int32_t* base,vuint32m8_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i32m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i64m1_m(vbool64_t mask,int64_t* base,vuint32mf2_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i64m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i64m2_m(vbool32_t mask,int64_t* base,vuint32m1_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i64m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i64m4_m(vbool16_t mask,int64_t* base,vuint32m2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i64m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_i64m8_m(vbool8_t mask,int64_t* base,vuint32m4_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_i64m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u8mf8_m(vbool64_t mask,uint8_t* base,vuint32mf2_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u8mf8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u8mf4_m(vbool32_t mask,uint8_t* base,vuint32m1_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u8mf4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u8mf2_m(vbool16_t mask,uint8_t* base,vuint32m2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u8mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u8m1_m(vbool8_t mask,uint8_t* base,vuint32m4_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u8m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u8m2_m(vbool4_t mask,uint8_t* base,vuint32m8_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u8m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u16mf4_m(vbool64_t mask,uint16_t* base,vuint32mf2_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u16mf4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u16mf2_m(vbool32_t mask,uint16_t* base,vuint32m1_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u16mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u16m1_m(vbool16_t mask,uint16_t* base,vuint32m2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u16m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u16m2_m(vbool8_t mask,uint16_t* base,vuint32m4_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u16m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u16m4_m(vbool4_t mask,uint16_t* base,vuint32m8_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u16m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u32mf2_m(vbool64_t mask,uint32_t* base,vuint32mf2_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u32mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u32m1_m(vbool32_t mask,uint32_t* base,vuint32m1_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u32m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u32m2_m(vbool16_t mask,uint32_t* base,vuint32m2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u32m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u32m4_m(vbool8_t mask,uint32_t* base,vuint32m4_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u32m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u32m8_m(vbool4_t mask,uint32_t* base,vuint32m8_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u32m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u64m1_m(vbool64_t mask,uint64_t* base,vuint32mf2_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u64m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u64m2_m(vbool32_t mask,uint64_t* base,vuint32m1_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u64m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u64m4_m(vbool16_t mask,uint64_t* base,vuint32m2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u64m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_u64m8_m(vbool8_t mask,uint64_t* base,vuint32m4_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_u64m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_f32mf2_m(vbool64_t mask,float* base,vuint32mf2_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f32mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_f32m1_m(vbool32_t mask,float* base,vuint32m1_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f32m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_f32m2_m(vbool16_t mask,float* base,vuint32m2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f32m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_f32m4_m(vbool8_t mask,float* base,vuint32m4_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f32m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_f32m8_m(vbool4_t mask,float* base,vuint32m8_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f32m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_f64m1_m(vbool64_t mask,double* base,vuint32mf2_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f64m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_f64m2_m(vbool32_t mask,double* base,vuint32m1_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f64m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_f64m4_m(vbool16_t mask,double* base,vuint32m2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f64m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei32_v_f64m8_m(vbool8_t mask,double* base,vuint32m4_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei32_v_f64m8_m(mask,base,bindex,value,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei32\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei64_v-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei64_v-1.c
new file mode 100644
index 0000000..c1bbc3b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei64_v-1.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei64_v_i8mf8(int8_t* base,vuint64m1_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i8mf8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_i8mf4(int8_t* base,vuint64m2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i8mf4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_i8mf2(int8_t* base,vuint64m4_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i8mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_i8m1(int8_t* base,vuint64m8_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i8m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_i16mf4(int16_t* base,vuint64m1_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i16mf4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_i16mf2(int16_t* base,vuint64m2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i16mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_i16m1(int16_t* base,vuint64m4_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i16m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_i16m2(int16_t* base,vuint64m8_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i16m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_i32mf2(int32_t* base,vuint64m1_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i32mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_i32m1(int32_t* base,vuint64m2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i32m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_i32m2(int32_t* base,vuint64m4_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i32m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_i32m4(int32_t* base,vuint64m8_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i32m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_i64m1(int64_t* base,vuint64m1_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i64m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_i64m2(int64_t* base,vuint64m2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i64m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_i64m4(int64_t* base,vuint64m4_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i64m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_i64m8(int64_t* base,vuint64m8_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i64m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_u8mf8(uint8_t* base,vuint64m1_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u8mf8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_u8mf4(uint8_t* base,vuint64m2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u8mf4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_u8mf2(uint8_t* base,vuint64m4_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u8mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_u8m1(uint8_t* base,vuint64m8_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u8m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_u16mf4(uint16_t* base,vuint64m1_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u16mf4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_u16mf2(uint16_t* base,vuint64m2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u16mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_u16m1(uint16_t* base,vuint64m4_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u16m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_u16m2(uint16_t* base,vuint64m8_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u16m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_u32mf2(uint32_t* base,vuint64m1_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u32mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_u32m1(uint32_t* base,vuint64m2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u32m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_u32m2(uint32_t* base,vuint64m4_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u32m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_u32m4(uint32_t* base,vuint64m8_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u32m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_u64m1(uint64_t* base,vuint64m1_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u64m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_u64m2(uint64_t* base,vuint64m2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u64m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_u64m4(uint64_t* base,vuint64m4_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u64m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_u64m8(uint64_t* base,vuint64m8_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u64m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_f32mf2(float* base,vuint64m1_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f32mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_f32m1(float* base,vuint64m2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f32m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_f32m2(float* base,vuint64m4_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f32m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_f32m4(float* base,vuint64m8_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f32m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_f64m1(double* base,vuint64m1_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f64m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_f64m2(double* base,vuint64m2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f64m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_f64m4(double* base,vuint64m4_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f64m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_f64m8(double* base,vuint64m8_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f64m8(base,bindex,value,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei64_v-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei64_v-2.c
new file mode 100644
index 0000000..7ce64d1
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei64_v-2.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei64_v_i8mf8(int8_t* base,vuint64m1_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i8mf8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_i8mf4(int8_t* base,vuint64m2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i8mf4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_i8mf2(int8_t* base,vuint64m4_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i8mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_i8m1(int8_t* base,vuint64m8_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i8m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_i16mf4(int16_t* base,vuint64m1_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i16mf4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_i16mf2(int16_t* base,vuint64m2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i16mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_i16m1(int16_t* base,vuint64m4_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i16m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_i16m2(int16_t* base,vuint64m8_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i16m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_i32mf2(int32_t* base,vuint64m1_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i32mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_i32m1(int32_t* base,vuint64m2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i32m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_i32m2(int32_t* base,vuint64m4_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i32m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_i32m4(int32_t* base,vuint64m8_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i32m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_i64m1(int64_t* base,vuint64m1_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i64m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_i64m2(int64_t* base,vuint64m2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i64m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_i64m4(int64_t* base,vuint64m4_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i64m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_i64m8(int64_t* base,vuint64m8_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i64m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_u8mf8(uint8_t* base,vuint64m1_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u8mf8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_u8mf4(uint8_t* base,vuint64m2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u8mf4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_u8mf2(uint8_t* base,vuint64m4_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u8mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_u8m1(uint8_t* base,vuint64m8_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u8m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_u16mf4(uint16_t* base,vuint64m1_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u16mf4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_u16mf2(uint16_t* base,vuint64m2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u16mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_u16m1(uint16_t* base,vuint64m4_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u16m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_u16m2(uint16_t* base,vuint64m8_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u16m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_u32mf2(uint32_t* base,vuint64m1_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u32mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_u32m1(uint32_t* base,vuint64m2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u32m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_u32m2(uint32_t* base,vuint64m4_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u32m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_u32m4(uint32_t* base,vuint64m8_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u32m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_u64m1(uint64_t* base,vuint64m1_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u64m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_u64m2(uint64_t* base,vuint64m2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u64m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_u64m4(uint64_t* base,vuint64m4_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u64m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_u64m8(uint64_t* base,vuint64m8_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u64m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_f32mf2(float* base,vuint64m1_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f32mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_f32m1(float* base,vuint64m2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f32m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_f32m2(float* base,vuint64m4_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f32m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_f32m4(float* base,vuint64m8_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f32m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_f64m1(double* base,vuint64m1_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f64m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_f64m2(double* base,vuint64m2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f64m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_f64m4(double* base,vuint64m4_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f64m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_f64m8(double* base,vuint64m8_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f64m8(base,bindex,value,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei64_v-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei64_v-3.c
new file mode 100644
index 0000000..ef4f763
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei64_v-3.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei64_v_i8mf8(int8_t* base,vuint64m1_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i8mf8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_i8mf4(int8_t* base,vuint64m2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i8mf4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_i8mf2(int8_t* base,vuint64m4_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i8mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_i8m1(int8_t* base,vuint64m8_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i8m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_i16mf4(int16_t* base,vuint64m1_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i16mf4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_i16mf2(int16_t* base,vuint64m2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i16mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_i16m1(int16_t* base,vuint64m4_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i16m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_i16m2(int16_t* base,vuint64m8_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i16m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_i32mf2(int32_t* base,vuint64m1_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i32mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_i32m1(int32_t* base,vuint64m2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i32m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_i32m2(int32_t* base,vuint64m4_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i32m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_i32m4(int32_t* base,vuint64m8_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i32m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_i64m1(int64_t* base,vuint64m1_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i64m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_i64m2(int64_t* base,vuint64m2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i64m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_i64m4(int64_t* base,vuint64m4_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i64m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_i64m8(int64_t* base,vuint64m8_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i64m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_u8mf8(uint8_t* base,vuint64m1_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u8mf8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_u8mf4(uint8_t* base,vuint64m2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u8mf4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_u8mf2(uint8_t* base,vuint64m4_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u8mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_u8m1(uint8_t* base,vuint64m8_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u8m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_u16mf4(uint16_t* base,vuint64m1_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u16mf4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_u16mf2(uint16_t* base,vuint64m2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u16mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_u16m1(uint16_t* base,vuint64m4_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u16m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_u16m2(uint16_t* base,vuint64m8_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u16m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_u32mf2(uint32_t* base,vuint64m1_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u32mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_u32m1(uint32_t* base,vuint64m2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u32m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_u32m2(uint32_t* base,vuint64m4_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u32m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_u32m4(uint32_t* base,vuint64m8_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u32m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_u64m1(uint64_t* base,vuint64m1_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u64m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_u64m2(uint64_t* base,vuint64m2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u64m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_u64m4(uint64_t* base,vuint64m4_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u64m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_u64m8(uint64_t* base,vuint64m8_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u64m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_f32mf2(float* base,vuint64m1_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f32mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_f32m1(float* base,vuint64m2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f32m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_f32m2(float* base,vuint64m4_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f32m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_f32m4(float* base,vuint64m8_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f32m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_f64m1(double* base,vuint64m1_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f64m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_f64m2(double* base,vuint64m2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f64m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_f64m4(double* base,vuint64m4_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f64m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_f64m8(double* base,vuint64m8_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f64m8(base,bindex,value,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei64_v_m-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei64_v_m-1.c
new file mode 100644
index 0000000..5ddcdab
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei64_v_m-1.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei64_v_i8mf8_m(vbool64_t mask,int8_t* base,vuint64m1_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i8mf8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_i8mf4_m(vbool32_t mask,int8_t* base,vuint64m2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i8mf4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_i8mf2_m(vbool16_t mask,int8_t* base,vuint64m4_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i8mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_i8m1_m(vbool8_t mask,int8_t* base,vuint64m8_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i8m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_i16mf4_m(vbool64_t mask,int16_t* base,vuint64m1_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i16mf4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_i16mf2_m(vbool32_t mask,int16_t* base,vuint64m2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i16mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_i16m1_m(vbool16_t mask,int16_t* base,vuint64m4_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i16m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_i16m2_m(vbool8_t mask,int16_t* base,vuint64m8_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i16m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_i32mf2_m(vbool64_t mask,int32_t* base,vuint64m1_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i32mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_i32m1_m(vbool32_t mask,int32_t* base,vuint64m2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i32m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_i32m2_m(vbool16_t mask,int32_t* base,vuint64m4_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i32m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_i32m4_m(vbool8_t mask,int32_t* base,vuint64m8_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i32m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_i64m1_m(vbool64_t mask,int64_t* base,vuint64m1_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i64m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_i64m2_m(vbool32_t mask,int64_t* base,vuint64m2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i64m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_i64m4_m(vbool16_t mask,int64_t* base,vuint64m4_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i64m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_i64m8_m(vbool8_t mask,int64_t* base,vuint64m8_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i64m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_u8mf8_m(vbool64_t mask,uint8_t* base,vuint64m1_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u8mf8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_u8mf4_m(vbool32_t mask,uint8_t* base,vuint64m2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u8mf4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_u8mf2_m(vbool16_t mask,uint8_t* base,vuint64m4_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u8mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_u8m1_m(vbool8_t mask,uint8_t* base,vuint64m8_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u8m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_u16mf4_m(vbool64_t mask,uint16_t* base,vuint64m1_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u16mf4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_u16mf2_m(vbool32_t mask,uint16_t* base,vuint64m2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u16mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_u16m1_m(vbool16_t mask,uint16_t* base,vuint64m4_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u16m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_u16m2_m(vbool8_t mask,uint16_t* base,vuint64m8_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u16m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_u32mf2_m(vbool64_t mask,uint32_t* base,vuint64m1_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u32mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_u32m1_m(vbool32_t mask,uint32_t* base,vuint64m2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u32m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_u32m2_m(vbool16_t mask,uint32_t* base,vuint64m4_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u32m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_u32m4_m(vbool8_t mask,uint32_t* base,vuint64m8_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u32m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_u64m1_m(vbool64_t mask,uint64_t* base,vuint64m1_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u64m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_u64m2_m(vbool32_t mask,uint64_t* base,vuint64m2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u64m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_u64m4_m(vbool16_t mask,uint64_t* base,vuint64m4_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u64m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_u64m8_m(vbool8_t mask,uint64_t* base,vuint64m8_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u64m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_f32mf2_m(vbool64_t mask,float* base,vuint64m1_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f32mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_f32m1_m(vbool32_t mask,float* base,vuint64m2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f32m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_f32m2_m(vbool16_t mask,float* base,vuint64m4_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f32m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_f32m4_m(vbool8_t mask,float* base,vuint64m8_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f32m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_f64m1_m(vbool64_t mask,double* base,vuint64m1_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f64m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_f64m2_m(vbool32_t mask,double* base,vuint64m2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f64m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_f64m4_m(vbool16_t mask,double* base,vuint64m4_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f64m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei64_v_f64m8_m(vbool8_t mask,double* base,vuint64m8_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f64m8_m(mask,base,bindex,value,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei64_v_m-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei64_v_m-2.c
new file mode 100644
index 0000000..fc0965d
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei64_v_m-2.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei64_v_i8mf8_m(vbool64_t mask,int8_t* base,vuint64m1_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i8mf8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_i8mf4_m(vbool32_t mask,int8_t* base,vuint64m2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i8mf4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_i8mf2_m(vbool16_t mask,int8_t* base,vuint64m4_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i8mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_i8m1_m(vbool8_t mask,int8_t* base,vuint64m8_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i8m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_i16mf4_m(vbool64_t mask,int16_t* base,vuint64m1_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i16mf4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_i16mf2_m(vbool32_t mask,int16_t* base,vuint64m2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i16mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_i16m1_m(vbool16_t mask,int16_t* base,vuint64m4_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i16m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_i16m2_m(vbool8_t mask,int16_t* base,vuint64m8_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i16m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_i32mf2_m(vbool64_t mask,int32_t* base,vuint64m1_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i32mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_i32m1_m(vbool32_t mask,int32_t* base,vuint64m2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i32m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_i32m2_m(vbool16_t mask,int32_t* base,vuint64m4_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i32m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_i32m4_m(vbool8_t mask,int32_t* base,vuint64m8_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i32m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_i64m1_m(vbool64_t mask,int64_t* base,vuint64m1_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i64m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_i64m2_m(vbool32_t mask,int64_t* base,vuint64m2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i64m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_i64m4_m(vbool16_t mask,int64_t* base,vuint64m4_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i64m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_i64m8_m(vbool8_t mask,int64_t* base,vuint64m8_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i64m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_u8mf8_m(vbool64_t mask,uint8_t* base,vuint64m1_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u8mf8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_u8mf4_m(vbool32_t mask,uint8_t* base,vuint64m2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u8mf4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_u8mf2_m(vbool16_t mask,uint8_t* base,vuint64m4_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u8mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_u8m1_m(vbool8_t mask,uint8_t* base,vuint64m8_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u8m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_u16mf4_m(vbool64_t mask,uint16_t* base,vuint64m1_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u16mf4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_u16mf2_m(vbool32_t mask,uint16_t* base,vuint64m2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u16mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_u16m1_m(vbool16_t mask,uint16_t* base,vuint64m4_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u16m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_u16m2_m(vbool8_t mask,uint16_t* base,vuint64m8_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u16m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_u32mf2_m(vbool64_t mask,uint32_t* base,vuint64m1_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u32mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_u32m1_m(vbool32_t mask,uint32_t* base,vuint64m2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u32m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_u32m2_m(vbool16_t mask,uint32_t* base,vuint64m4_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u32m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_u32m4_m(vbool8_t mask,uint32_t* base,vuint64m8_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u32m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_u64m1_m(vbool64_t mask,uint64_t* base,vuint64m1_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u64m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_u64m2_m(vbool32_t mask,uint64_t* base,vuint64m2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u64m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_u64m4_m(vbool16_t mask,uint64_t* base,vuint64m4_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u64m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_u64m8_m(vbool8_t mask,uint64_t* base,vuint64m8_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u64m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_f32mf2_m(vbool64_t mask,float* base,vuint64m1_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f32mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_f32m1_m(vbool32_t mask,float* base,vuint64m2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f32m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_f32m2_m(vbool16_t mask,float* base,vuint64m4_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f32m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_f32m4_m(vbool8_t mask,float* base,vuint64m8_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f32m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_f64m1_m(vbool64_t mask,double* base,vuint64m1_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f64m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_f64m2_m(vbool32_t mask,double* base,vuint64m2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f64m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_f64m4_m(vbool16_t mask,double* base,vuint64m4_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f64m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei64_v_f64m8_m(vbool8_t mask,double* base,vuint64m8_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f64m8_m(mask,base,bindex,value,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei64_v_m-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei64_v_m-3.c
new file mode 100644
index 0000000..8f32f6c
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei64_v_m-3.c
@@ -0,0 +1,262 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei64_v_i8mf8_m(vbool64_t mask,int8_t* base,vuint64m1_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i8mf8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_i8mf4_m(vbool32_t mask,int8_t* base,vuint64m2_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i8mf4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_i8mf2_m(vbool16_t mask,int8_t* base,vuint64m4_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i8mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_i8m1_m(vbool8_t mask,int8_t* base,vuint64m8_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i8m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_i16mf4_m(vbool64_t mask,int16_t* base,vuint64m1_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i16mf4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_i16mf2_m(vbool32_t mask,int16_t* base,vuint64m2_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i16mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_i16m1_m(vbool16_t mask,int16_t* base,vuint64m4_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i16m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_i16m2_m(vbool8_t mask,int16_t* base,vuint64m8_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i16m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_i32mf2_m(vbool64_t mask,int32_t* base,vuint64m1_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i32mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_i32m1_m(vbool32_t mask,int32_t* base,vuint64m2_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i32m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_i32m2_m(vbool16_t mask,int32_t* base,vuint64m4_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i32m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_i32m4_m(vbool8_t mask,int32_t* base,vuint64m8_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i32m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_i64m1_m(vbool64_t mask,int64_t* base,vuint64m1_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i64m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_i64m2_m(vbool32_t mask,int64_t* base,vuint64m2_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i64m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_i64m4_m(vbool16_t mask,int64_t* base,vuint64m4_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i64m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_i64m8_m(vbool8_t mask,int64_t* base,vuint64m8_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_i64m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_u8mf8_m(vbool64_t mask,uint8_t* base,vuint64m1_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u8mf8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_u8mf4_m(vbool32_t mask,uint8_t* base,vuint64m2_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u8mf4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_u8mf2_m(vbool16_t mask,uint8_t* base,vuint64m4_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u8mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_u8m1_m(vbool8_t mask,uint8_t* base,vuint64m8_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u8m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_u16mf4_m(vbool64_t mask,uint16_t* base,vuint64m1_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u16mf4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_u16mf2_m(vbool32_t mask,uint16_t* base,vuint64m2_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u16mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_u16m1_m(vbool16_t mask,uint16_t* base,vuint64m4_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u16m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_u16m2_m(vbool8_t mask,uint16_t* base,vuint64m8_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u16m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_u32mf2_m(vbool64_t mask,uint32_t* base,vuint64m1_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u32mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_u32m1_m(vbool32_t mask,uint32_t* base,vuint64m2_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u32m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_u32m2_m(vbool16_t mask,uint32_t* base,vuint64m4_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u32m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_u32m4_m(vbool8_t mask,uint32_t* base,vuint64m8_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u32m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_u64m1_m(vbool64_t mask,uint64_t* base,vuint64m1_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u64m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_u64m2_m(vbool32_t mask,uint64_t* base,vuint64m2_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u64m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_u64m4_m(vbool16_t mask,uint64_t* base,vuint64m4_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u64m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_u64m8_m(vbool8_t mask,uint64_t* base,vuint64m8_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_u64m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_f32mf2_m(vbool64_t mask,float* base,vuint64m1_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f32mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_f32m1_m(vbool32_t mask,float* base,vuint64m2_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f32m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_f32m2_m(vbool16_t mask,float* base,vuint64m4_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f32m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_f32m4_m(vbool8_t mask,float* base,vuint64m8_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f32m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_f64m1_m(vbool64_t mask,double* base,vuint64m1_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f64m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_f64m2_m(vbool32_t mask,double* base,vuint64m2_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f64m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_f64m4_m(vbool16_t mask,double* base,vuint64m4_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f64m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei64_v_f64m8_m(vbool8_t mask,double* base,vuint64m8_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei64_v_f64m8_m(mask,base,bindex,value,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei64\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei8_v-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei8_v-1.c
new file mode 100644
index 0000000..809985f
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei8_v-1.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei8_v_i8mf8(int8_t* base,vuint8mf8_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8mf8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i8mf4(int8_t* base,vuint8mf4_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8mf4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i8mf2(int8_t* base,vuint8mf2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i8m1(int8_t* base,vuint8m1_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i8m2(int8_t* base,vuint8m2_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i8m4(int8_t* base,vuint8m4_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i8m8(int8_t* base,vuint8m8_t bindex,vint8m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i16mf4(int16_t* base,vuint8mf8_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16mf4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i16mf2(int16_t* base,vuint8mf4_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i16m1(int16_t* base,vuint8mf2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i16m2(int16_t* base,vuint8m1_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i16m4(int16_t* base,vuint8m2_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i16m8(int16_t* base,vuint8m4_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i32mf2(int32_t* base,vuint8mf8_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i32mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i32m1(int32_t* base,vuint8mf4_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i32m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i32m2(int32_t* base,vuint8mf2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i32m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i32m4(int32_t* base,vuint8m1_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i32m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i32m8(int32_t* base,vuint8m2_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i32m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i64m1(int64_t* base,vuint8mf8_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i64m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i64m2(int64_t* base,vuint8mf4_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i64m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i64m4(int64_t* base,vuint8mf2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i64m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i64m8(int64_t* base,vuint8m1_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i64m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u8mf8(uint8_t* base,vuint8mf8_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8mf8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u8mf4(uint8_t* base,vuint8mf4_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8mf4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u8mf2(uint8_t* base,vuint8mf2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u8m1(uint8_t* base,vuint8m1_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u8m2(uint8_t* base,vuint8m2_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u8m4(uint8_t* base,vuint8m4_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u8m8(uint8_t* base,vuint8m8_t bindex,vuint8m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u16mf4(uint16_t* base,vuint8mf8_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16mf4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u16mf2(uint16_t* base,vuint8mf4_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u16m1(uint16_t* base,vuint8mf2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u16m2(uint16_t* base,vuint8m1_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u16m4(uint16_t* base,vuint8m2_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u16m8(uint16_t* base,vuint8m4_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u32mf2(uint32_t* base,vuint8mf8_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u32mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u32m1(uint32_t* base,vuint8mf4_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u32m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u32m2(uint32_t* base,vuint8mf2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u32m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u32m4(uint32_t* base,vuint8m1_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u32m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u32m8(uint32_t* base,vuint8m2_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u32m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u64m1(uint64_t* base,vuint8mf8_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u64m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u64m2(uint64_t* base,vuint8mf4_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u64m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u64m4(uint64_t* base,vuint8mf2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u64m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u64m8(uint64_t* base,vuint8m1_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u64m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_f32mf2(float* base,vuint8mf8_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f32mf2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_f32m1(float* base,vuint8mf4_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f32m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_f32m2(float* base,vuint8mf2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f32m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_f32m4(float* base,vuint8m1_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f32m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_f32m8(float* base,vuint8m2_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f32m8(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_f64m1(double* base,vuint8mf8_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f64m1(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_f64m2(double* base,vuint8mf4_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f64m2(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_f64m4(double* base,vuint8mf2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f64m4(base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_f64m8(double* base,vuint8m1_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f64m8(base,bindex,value,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei8_v-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei8_v-2.c
new file mode 100644
index 0000000..60faaab
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei8_v-2.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei8_v_i8mf8(int8_t* base,vuint8mf8_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8mf8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i8mf4(int8_t* base,vuint8mf4_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8mf4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i8mf2(int8_t* base,vuint8mf2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i8m1(int8_t* base,vuint8m1_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i8m2(int8_t* base,vuint8m2_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i8m4(int8_t* base,vuint8m4_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i8m8(int8_t* base,vuint8m8_t bindex,vint8m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i16mf4(int16_t* base,vuint8mf8_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16mf4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i16mf2(int16_t* base,vuint8mf4_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i16m1(int16_t* base,vuint8mf2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i16m2(int16_t* base,vuint8m1_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i16m4(int16_t* base,vuint8m2_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i16m8(int16_t* base,vuint8m4_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i32mf2(int32_t* base,vuint8mf8_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i32mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i32m1(int32_t* base,vuint8mf4_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i32m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i32m2(int32_t* base,vuint8mf2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i32m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i32m4(int32_t* base,vuint8m1_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i32m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i32m8(int32_t* base,vuint8m2_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i32m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i64m1(int64_t* base,vuint8mf8_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i64m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i64m2(int64_t* base,vuint8mf4_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i64m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i64m4(int64_t* base,vuint8mf2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i64m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i64m8(int64_t* base,vuint8m1_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i64m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u8mf8(uint8_t* base,vuint8mf8_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8mf8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u8mf4(uint8_t* base,vuint8mf4_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8mf4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u8mf2(uint8_t* base,vuint8mf2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u8m1(uint8_t* base,vuint8m1_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u8m2(uint8_t* base,vuint8m2_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u8m4(uint8_t* base,vuint8m4_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u8m8(uint8_t* base,vuint8m8_t bindex,vuint8m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u16mf4(uint16_t* base,vuint8mf8_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16mf4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u16mf2(uint16_t* base,vuint8mf4_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u16m1(uint16_t* base,vuint8mf2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u16m2(uint16_t* base,vuint8m1_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u16m4(uint16_t* base,vuint8m2_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u16m8(uint16_t* base,vuint8m4_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u32mf2(uint32_t* base,vuint8mf8_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u32mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u32m1(uint32_t* base,vuint8mf4_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u32m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u32m2(uint32_t* base,vuint8mf2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u32m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u32m4(uint32_t* base,vuint8m1_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u32m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u32m8(uint32_t* base,vuint8m2_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u32m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u64m1(uint64_t* base,vuint8mf8_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u64m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u64m2(uint64_t* base,vuint8mf4_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u64m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u64m4(uint64_t* base,vuint8mf2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u64m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u64m8(uint64_t* base,vuint8m1_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u64m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_f32mf2(float* base,vuint8mf8_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f32mf2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_f32m1(float* base,vuint8mf4_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f32m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_f32m2(float* base,vuint8mf2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f32m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_f32m4(float* base,vuint8m1_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f32m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_f32m8(float* base,vuint8m2_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f32m8(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_f64m1(double* base,vuint8mf8_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f64m1(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_f64m2(double* base,vuint8mf4_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f64m2(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_f64m4(double* base,vuint8mf2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f64m4(base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_f64m8(double* base,vuint8m1_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f64m8(base,bindex,value,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei8_v-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei8_v-3.c
new file mode 100644
index 0000000..ba193c5
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei8_v-3.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei8_v_i8mf8(int8_t* base,vuint8mf8_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8mf8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i8mf4(int8_t* base,vuint8mf4_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8mf4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i8mf2(int8_t* base,vuint8mf2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i8m1(int8_t* base,vuint8m1_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i8m2(int8_t* base,vuint8m2_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i8m4(int8_t* base,vuint8m4_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i8m8(int8_t* base,vuint8m8_t bindex,vint8m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i16mf4(int16_t* base,vuint8mf8_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16mf4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i16mf2(int16_t* base,vuint8mf4_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i16m1(int16_t* base,vuint8mf2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i16m2(int16_t* base,vuint8m1_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i16m4(int16_t* base,vuint8m2_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i16m8(int16_t* base,vuint8m4_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i32mf2(int32_t* base,vuint8mf8_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i32mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i32m1(int32_t* base,vuint8mf4_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i32m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i32m2(int32_t* base,vuint8mf2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i32m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i32m4(int32_t* base,vuint8m1_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i32m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i32m8(int32_t* base,vuint8m2_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i32m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i64m1(int64_t* base,vuint8mf8_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i64m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i64m2(int64_t* base,vuint8mf4_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i64m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i64m4(int64_t* base,vuint8mf2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i64m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i64m8(int64_t* base,vuint8m1_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i64m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u8mf8(uint8_t* base,vuint8mf8_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8mf8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u8mf4(uint8_t* base,vuint8mf4_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8mf4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u8mf2(uint8_t* base,vuint8mf2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u8m1(uint8_t* base,vuint8m1_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u8m2(uint8_t* base,vuint8m2_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u8m4(uint8_t* base,vuint8m4_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u8m8(uint8_t* base,vuint8m8_t bindex,vuint8m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u16mf4(uint16_t* base,vuint8mf8_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16mf4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u16mf2(uint16_t* base,vuint8mf4_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u16m1(uint16_t* base,vuint8mf2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u16m2(uint16_t* base,vuint8m1_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u16m4(uint16_t* base,vuint8m2_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u16m8(uint16_t* base,vuint8m4_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u32mf2(uint32_t* base,vuint8mf8_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u32mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u32m1(uint32_t* base,vuint8mf4_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u32m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u32m2(uint32_t* base,vuint8mf2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u32m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u32m4(uint32_t* base,vuint8m1_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u32m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u32m8(uint32_t* base,vuint8m2_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u32m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u64m1(uint64_t* base,vuint8mf8_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u64m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u64m2(uint64_t* base,vuint8mf4_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u64m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u64m4(uint64_t* base,vuint8mf2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u64m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u64m8(uint64_t* base,vuint8m1_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u64m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_f32mf2(float* base,vuint8mf8_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f32mf2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_f32m1(float* base,vuint8mf4_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f32m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_f32m2(float* base,vuint8mf2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f32m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_f32m4(float* base,vuint8m1_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f32m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_f32m8(float* base,vuint8m2_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f32m8(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_f64m1(double* base,vuint8mf8_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f64m1(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_f64m2(double* base,vuint8mf4_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f64m2(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_f64m4(double* base,vuint8mf2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f64m4(base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_f64m8(double* base,vuint8m1_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f64m8(base,bindex,value,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei8_v_m-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei8_v_m-1.c
new file mode 100644
index 0000000..7f9ecb5
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei8_v_m-1.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei8_v_i8mf8_m(vbool64_t mask,int8_t* base,vuint8mf8_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8mf8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i8mf4_m(vbool32_t mask,int8_t* base,vuint8mf4_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8mf4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i8mf2_m(vbool16_t mask,int8_t* base,vuint8mf2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i8m1_m(vbool8_t mask,int8_t* base,vuint8m1_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i8m2_m(vbool4_t mask,int8_t* base,vuint8m2_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i8m4_m(vbool2_t mask,int8_t* base,vuint8m4_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i8m8_m(vbool1_t mask,int8_t* base,vuint8m8_t bindex,vint8m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i16mf4_m(vbool64_t mask,int16_t* base,vuint8mf8_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16mf4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i16mf2_m(vbool32_t mask,int16_t* base,vuint8mf4_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i16m1_m(vbool16_t mask,int16_t* base,vuint8mf2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i16m2_m(vbool8_t mask,int16_t* base,vuint8m1_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i16m4_m(vbool4_t mask,int16_t* base,vuint8m2_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i16m8_m(vbool2_t mask,int16_t* base,vuint8m4_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i32mf2_m(vbool64_t mask,int32_t* base,vuint8mf8_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i32mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i32m1_m(vbool32_t mask,int32_t* base,vuint8mf4_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i32m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i32m2_m(vbool16_t mask,int32_t* base,vuint8mf2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i32m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i32m4_m(vbool8_t mask,int32_t* base,vuint8m1_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i32m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i32m8_m(vbool4_t mask,int32_t* base,vuint8m2_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i32m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i64m1_m(vbool64_t mask,int64_t* base,vuint8mf8_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i64m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i64m2_m(vbool32_t mask,int64_t* base,vuint8mf4_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i64m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i64m4_m(vbool16_t mask,int64_t* base,vuint8mf2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i64m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_i64m8_m(vbool8_t mask,int64_t* base,vuint8m1_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i64m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u8mf8_m(vbool64_t mask,uint8_t* base,vuint8mf8_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8mf8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u8mf4_m(vbool32_t mask,uint8_t* base,vuint8mf4_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8mf4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u8mf2_m(vbool16_t mask,uint8_t* base,vuint8mf2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u8m1_m(vbool8_t mask,uint8_t* base,vuint8m1_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u8m2_m(vbool4_t mask,uint8_t* base,vuint8m2_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u8m4_m(vbool2_t mask,uint8_t* base,vuint8m4_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u8m8_m(vbool1_t mask,uint8_t* base,vuint8m8_t bindex,vuint8m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u16mf4_m(vbool64_t mask,uint16_t* base,vuint8mf8_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16mf4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u16mf2_m(vbool32_t mask,uint16_t* base,vuint8mf4_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u16m1_m(vbool16_t mask,uint16_t* base,vuint8mf2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u16m2_m(vbool8_t mask,uint16_t* base,vuint8m1_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u16m4_m(vbool4_t mask,uint16_t* base,vuint8m2_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u16m8_m(vbool2_t mask,uint16_t* base,vuint8m4_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u32mf2_m(vbool64_t mask,uint32_t* base,vuint8mf8_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u32mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u32m1_m(vbool32_t mask,uint32_t* base,vuint8mf4_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u32m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u32m2_m(vbool16_t mask,uint32_t* base,vuint8mf2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u32m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u32m4_m(vbool8_t mask,uint32_t* base,vuint8m1_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u32m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u32m8_m(vbool4_t mask,uint32_t* base,vuint8m2_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u32m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u64m1_m(vbool64_t mask,uint64_t* base,vuint8mf8_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u64m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u64m2_m(vbool32_t mask,uint64_t* base,vuint8mf4_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u64m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u64m4_m(vbool16_t mask,uint64_t* base,vuint8mf2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u64m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_u64m8_m(vbool8_t mask,uint64_t* base,vuint8m1_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u64m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_f32mf2_m(vbool64_t mask,float* base,vuint8mf8_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f32mf2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_f32m1_m(vbool32_t mask,float* base,vuint8mf4_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f32m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_f32m2_m(vbool16_t mask,float* base,vuint8mf2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f32m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_f32m4_m(vbool8_t mask,float* base,vuint8m1_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f32m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_f32m8_m(vbool4_t mask,float* base,vuint8m2_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f32m8_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_f64m1_m(vbool64_t mask,double* base,vuint8mf8_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f64m1_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_f64m2_m(vbool32_t mask,double* base,vuint8mf4_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f64m2_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_f64m4_m(vbool16_t mask,double* base,vuint8mf2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f64m4_m(mask,base,bindex,value,vl);
+}
+
+
+void test___riscv_vsuxei8_v_f64m8_m(vbool8_t mask,double* base,vuint8m1_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f64m8_m(mask,base,bindex,value,vl);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei8_v_m-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei8_v_m-2.c
new file mode 100644
index 0000000..a9fc599
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei8_v_m-2.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei8_v_i8mf8_m(vbool64_t mask,int8_t* base,vuint8mf8_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8mf8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i8mf4_m(vbool32_t mask,int8_t* base,vuint8mf4_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8mf4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i8mf2_m(vbool16_t mask,int8_t* base,vuint8mf2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i8m1_m(vbool8_t mask,int8_t* base,vuint8m1_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i8m2_m(vbool4_t mask,int8_t* base,vuint8m2_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i8m4_m(vbool2_t mask,int8_t* base,vuint8m4_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i8m8_m(vbool1_t mask,int8_t* base,vuint8m8_t bindex,vint8m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i16mf4_m(vbool64_t mask,int16_t* base,vuint8mf8_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16mf4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i16mf2_m(vbool32_t mask,int16_t* base,vuint8mf4_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i16m1_m(vbool16_t mask,int16_t* base,vuint8mf2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i16m2_m(vbool8_t mask,int16_t* base,vuint8m1_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i16m4_m(vbool4_t mask,int16_t* base,vuint8m2_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i16m8_m(vbool2_t mask,int16_t* base,vuint8m4_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i32mf2_m(vbool64_t mask,int32_t* base,vuint8mf8_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i32mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i32m1_m(vbool32_t mask,int32_t* base,vuint8mf4_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i32m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i32m2_m(vbool16_t mask,int32_t* base,vuint8mf2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i32m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i32m4_m(vbool8_t mask,int32_t* base,vuint8m1_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i32m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i32m8_m(vbool4_t mask,int32_t* base,vuint8m2_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i32m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i64m1_m(vbool64_t mask,int64_t* base,vuint8mf8_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i64m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i64m2_m(vbool32_t mask,int64_t* base,vuint8mf4_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i64m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i64m4_m(vbool16_t mask,int64_t* base,vuint8mf2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i64m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_i64m8_m(vbool8_t mask,int64_t* base,vuint8m1_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i64m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u8mf8_m(vbool64_t mask,uint8_t* base,vuint8mf8_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8mf8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u8mf4_m(vbool32_t mask,uint8_t* base,vuint8mf4_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8mf4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u8mf2_m(vbool16_t mask,uint8_t* base,vuint8mf2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u8m1_m(vbool8_t mask,uint8_t* base,vuint8m1_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u8m2_m(vbool4_t mask,uint8_t* base,vuint8m2_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u8m4_m(vbool2_t mask,uint8_t* base,vuint8m4_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u8m8_m(vbool1_t mask,uint8_t* base,vuint8m8_t bindex,vuint8m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u16mf4_m(vbool64_t mask,uint16_t* base,vuint8mf8_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16mf4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u16mf2_m(vbool32_t mask,uint16_t* base,vuint8mf4_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u16m1_m(vbool16_t mask,uint16_t* base,vuint8mf2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u16m2_m(vbool8_t mask,uint16_t* base,vuint8m1_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u16m4_m(vbool4_t mask,uint16_t* base,vuint8m2_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u16m8_m(vbool2_t mask,uint16_t* base,vuint8m4_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u32mf2_m(vbool64_t mask,uint32_t* base,vuint8mf8_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u32mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u32m1_m(vbool32_t mask,uint32_t* base,vuint8mf4_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u32m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u32m2_m(vbool16_t mask,uint32_t* base,vuint8mf2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u32m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u32m4_m(vbool8_t mask,uint32_t* base,vuint8m1_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u32m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u32m8_m(vbool4_t mask,uint32_t* base,vuint8m2_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u32m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u64m1_m(vbool64_t mask,uint64_t* base,vuint8mf8_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u64m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u64m2_m(vbool32_t mask,uint64_t* base,vuint8mf4_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u64m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u64m4_m(vbool16_t mask,uint64_t* base,vuint8mf2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u64m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_u64m8_m(vbool8_t mask,uint64_t* base,vuint8m1_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u64m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_f32mf2_m(vbool64_t mask,float* base,vuint8mf8_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f32mf2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_f32m1_m(vbool32_t mask,float* base,vuint8mf4_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f32m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_f32m2_m(vbool16_t mask,float* base,vuint8mf2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f32m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_f32m4_m(vbool8_t mask,float* base,vuint8m1_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f32m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_f32m8_m(vbool4_t mask,float* base,vuint8m2_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f32m8_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_f64m1_m(vbool64_t mask,double* base,vuint8mf8_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f64m1_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_f64m2_m(vbool32_t mask,double* base,vuint8mf4_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f64m2_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_f64m4_m(vbool16_t mask,double* base,vuint8mf2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f64m4_m(mask,base,bindex,value,31);
+}
+
+
+void test___riscv_vsuxei8_v_f64m8_m(vbool8_t mask,double* base,vuint8m1_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f64m8_m(mask,base,bindex,value,31);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*31,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei8_v_m-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei8_v_m-3.c
new file mode 100644
index 0000000..d5d7a44
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/base/vsuxei8_v_m-3.c
@@ -0,0 +1,346 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void test___riscv_vsuxei8_v_i8mf8_m(vbool64_t mask,int8_t* base,vuint8mf8_t bindex,vint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8mf8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i8mf4_m(vbool32_t mask,int8_t* base,vuint8mf4_t bindex,vint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8mf4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i8mf2_m(vbool16_t mask,int8_t* base,vuint8mf2_t bindex,vint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i8m1_m(vbool8_t mask,int8_t* base,vuint8m1_t bindex,vint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i8m2_m(vbool4_t mask,int8_t* base,vuint8m2_t bindex,vint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i8m4_m(vbool2_t mask,int8_t* base,vuint8m4_t bindex,vint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i8m8_m(vbool1_t mask,int8_t* base,vuint8m8_t bindex,vint8m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i8m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i16mf4_m(vbool64_t mask,int16_t* base,vuint8mf8_t bindex,vint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16mf4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i16mf2_m(vbool32_t mask,int16_t* base,vuint8mf4_t bindex,vint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i16m1_m(vbool16_t mask,int16_t* base,vuint8mf2_t bindex,vint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i16m2_m(vbool8_t mask,int16_t* base,vuint8m1_t bindex,vint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i16m4_m(vbool4_t mask,int16_t* base,vuint8m2_t bindex,vint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i16m8_m(vbool2_t mask,int16_t* base,vuint8m4_t bindex,vint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i16m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i32mf2_m(vbool64_t mask,int32_t* base,vuint8mf8_t bindex,vint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i32mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i32m1_m(vbool32_t mask,int32_t* base,vuint8mf4_t bindex,vint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i32m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i32m2_m(vbool16_t mask,int32_t* base,vuint8mf2_t bindex,vint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i32m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i32m4_m(vbool8_t mask,int32_t* base,vuint8m1_t bindex,vint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i32m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i32m8_m(vbool4_t mask,int32_t* base,vuint8m2_t bindex,vint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i32m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i64m1_m(vbool64_t mask,int64_t* base,vuint8mf8_t bindex,vint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i64m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i64m2_m(vbool32_t mask,int64_t* base,vuint8mf4_t bindex,vint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i64m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i64m4_m(vbool16_t mask,int64_t* base,vuint8mf2_t bindex,vint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i64m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_i64m8_m(vbool8_t mask,int64_t* base,vuint8m1_t bindex,vint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_i64m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u8mf8_m(vbool64_t mask,uint8_t* base,vuint8mf8_t bindex,vuint8mf8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8mf8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u8mf4_m(vbool32_t mask,uint8_t* base,vuint8mf4_t bindex,vuint8mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8mf4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u8mf2_m(vbool16_t mask,uint8_t* base,vuint8mf2_t bindex,vuint8mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u8m1_m(vbool8_t mask,uint8_t* base,vuint8m1_t bindex,vuint8m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u8m2_m(vbool4_t mask,uint8_t* base,vuint8m2_t bindex,vuint8m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u8m4_m(vbool2_t mask,uint8_t* base,vuint8m4_t bindex,vuint8m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u8m8_m(vbool1_t mask,uint8_t* base,vuint8m8_t bindex,vuint8m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u8m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u16mf4_m(vbool64_t mask,uint16_t* base,vuint8mf8_t bindex,vuint16mf4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16mf4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u16mf2_m(vbool32_t mask,uint16_t* base,vuint8mf4_t bindex,vuint16mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u16m1_m(vbool16_t mask,uint16_t* base,vuint8mf2_t bindex,vuint16m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u16m2_m(vbool8_t mask,uint16_t* base,vuint8m1_t bindex,vuint16m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u16m4_m(vbool4_t mask,uint16_t* base,vuint8m2_t bindex,vuint16m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u16m8_m(vbool2_t mask,uint16_t* base,vuint8m4_t bindex,vuint16m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u16m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u32mf2_m(vbool64_t mask,uint32_t* base,vuint8mf8_t bindex,vuint32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u32mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u32m1_m(vbool32_t mask,uint32_t* base,vuint8mf4_t bindex,vuint32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u32m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u32m2_m(vbool16_t mask,uint32_t* base,vuint8mf2_t bindex,vuint32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u32m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u32m4_m(vbool8_t mask,uint32_t* base,vuint8m1_t bindex,vuint32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u32m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u32m8_m(vbool4_t mask,uint32_t* base,vuint8m2_t bindex,vuint32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u32m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u64m1_m(vbool64_t mask,uint64_t* base,vuint8mf8_t bindex,vuint64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u64m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u64m2_m(vbool32_t mask,uint64_t* base,vuint8mf4_t bindex,vuint64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u64m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u64m4_m(vbool16_t mask,uint64_t* base,vuint8mf2_t bindex,vuint64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u64m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_u64m8_m(vbool8_t mask,uint64_t* base,vuint8m1_t bindex,vuint64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_u64m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_f32mf2_m(vbool64_t mask,float* base,vuint8mf8_t bindex,vfloat32mf2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f32mf2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_f32m1_m(vbool32_t mask,float* base,vuint8mf4_t bindex,vfloat32m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f32m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_f32m2_m(vbool16_t mask,float* base,vuint8mf2_t bindex,vfloat32m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f32m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_f32m4_m(vbool8_t mask,float* base,vuint8m1_t bindex,vfloat32m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f32m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_f32m8_m(vbool4_t mask,float* base,vuint8m2_t bindex,vfloat32m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f32m8_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_f64m1_m(vbool64_t mask,double* base,vuint8mf8_t bindex,vfloat64m1_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f64m1_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_f64m2_m(vbool32_t mask,double* base,vuint8mf4_t bindex,vfloat64m2_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f64m2_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_f64m4_m(vbool16_t mask,double* base,vuint8mf2_t bindex,vfloat64m4_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f64m4_m(mask,base,bindex,value,32);
+}
+
+
+void test___riscv_vsuxei8_v_f64m8_m(vbool8_t mask,double* base,vuint8m1_t bindex,vfloat64m8_t value,size_t vl)
+{
+    __riscv_vsuxei8_v_f64m8_m(mask,base,bindex,value,32);
+}
+
+
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e16,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 2 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m1,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m2,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m4,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e64,\s*m8,\s*t[au],\s*m[au]\s+vsuxei8\.v\s+v[0-9]+,\s*0?\([a-x0-9]+\),\s*v[0-9]+,\s*v0.t} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-1.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-1.c
new file mode 100644
index 0000000..ea0faf6
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-1.c
@@ -0,0 +1,35 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int n, int cond)
+{
+  size_t vl;
+  switch (cond)
+  {
+  case 1:
+    vl = 100;
+    break;
+  case 2:
+    vl = *(size_t*)(in + 100);
+    break;
+  case 3:
+    {
+      size_t new_vl = *(size_t*)(in + 500);
+      size_t new_vl2 = *(size_t*)(in + 600);
+      vl = new_vl + new_vl2 + 777;
+      break;
+    }
+  default:
+    vl = vl + 4000;
+    break;
+  }
+  for (int i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i, vl);
+      __riscv_vse8_v_i8mf8 (out + i, v, vl);
+    }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle8\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-10.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-10.c
new file mode 100644
index 0000000..664f347
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-10.c
@@ -0,0 +1,73 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int l, int n, int m, int cond)
+{
+  size_t vl;
+  switch (cond)
+  {
+  case 1:
+    vl = 100;
+    break;
+  case 2:
+    vl = *(size_t*)(in + 100);
+    break;
+  case 3:
+    {
+      size_t new_vl = *(size_t*)(in + 500);
+      size_t new_vl2 = *(size_t*)(in + 600);
+      vl = new_vl + new_vl2 + 777;
+      break;
+    }
+  default:
+    break;
+  }
+  for (int i = 0; i < n; i++)
+    {
+      vint8mf8_t v1 = __riscv_vle8_v_i8mf8 (in + i + 1, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 1, v1, vl);
+
+      vint8mf8_t v2 = __riscv_vle8_v_i8mf8 (in + i + 2, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 2, v2, vl);
+
+      vint8mf8_t v3 = __riscv_vle8_v_i8mf8 (in + i + 3, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 3, v3, vl);
+
+      vint8mf8_t v4 = __riscv_vle8_v_i8mf8 (in + i + 4, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 4, v4, vl);
+
+      vint8mf8_t v5 = __riscv_vle8_v_i8mf8 (in + i + 5, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 5, v5, vl);
+
+      vint8mf8_t v6 = __riscv_vle8_v_i8mf8 (in + i + 6, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 6, v6, vl);
+
+      vint8mf8_t v7 = __riscv_vle8_v_i8mf8 (in + i + 7, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 7, v7, vl);
+
+      vint8mf8_t v8 = __riscv_vle8_v_i8mf8 (in + i + 8, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 8, v8, vl);
+
+      vint8mf8_t v9 = __riscv_vle8_v_i8mf8 (in + i + 9, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 9, v9, vl);
+
+      vint8mf8_t v10 = __riscv_vle8_v_i8mf8 (in + i + 10, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 10, v10, vl);
+
+      vint8mf8_t v11 = __riscv_vle8_v_i8mf8 (in + i + 11, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 11, v11, vl);
+
+      vint8mf8_t v12 = __riscv_vle8_v_i8mf8 (in + i + 12, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 12, v12, vl);
+
+      vint8mf8_t v13 = __riscv_vle8_v_i8mf8 (in + i + 13, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 13, v13, vl);
+
+      vint8mf8_t v14 = __riscv_vle8_v_i8mf8 (in + i + 14, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 14, v14, vl);
+    }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+add\s+\s*[a-x0-9]+,\s*[a-x0-9]+,\s*[a-x0-9]+\s+vle8\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-11.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-11.c
new file mode 100644
index 0000000..91812c9
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-11.c
@@ -0,0 +1,40 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int n, int cond)
+{
+  size_t vl;
+  switch (cond)
+  {
+  case 1:
+    vl = 100;
+    break;
+  case 2:
+    vl = *(size_t*)(in + 100);
+    break;
+  case 3:
+    {
+      size_t new_vl = *(size_t*)(in + 500);
+      size_t new_vl2 = *(size_t*)(in + 600);
+      vl = new_vl + new_vl2 + 777;
+      break;
+    }
+  default:
+    vl = vl + 4000;
+    break;
+  }
+  for (int i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i, vl);
+      __riscv_vse8_v_i8mf8 (out + i, v, vl);
+      
+      vint8mf2_t v2 = __riscv_vle8_v_i8mf2 (in + i + 100, vl);
+      __riscv_vse8_v_i8mf2 (out + i + 100, v2, vl);
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-12.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-12.c
new file mode 100644
index 0000000..a7a62bd
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-12.c
@@ -0,0 +1,39 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int n, int cond)
+{
+  size_t vl;
+  switch (cond)
+  {
+  case 1:
+    vl = 100;
+    break;
+  case 2:
+    vl = *(size_t*)(in + 100);
+    break;
+  case 3:
+    {
+      size_t new_vl = *(size_t*)(in + 500);
+      size_t new_vl2 = *(size_t*)(in + 600);
+      vl = new_vl + new_vl2 + 777;
+      break;
+    }
+  default:
+    vl = vl + 4000;
+    break;
+  }
+  for (int i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i, vl);
+      __riscv_vse8_v_i8mf8 (out + i, v, vl);
+      
+      vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + i + 100, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 100, v2, vl);
+    }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle8\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-13.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-13.c
new file mode 100644
index 0000000..fb1cbc5
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-13.c
@@ -0,0 +1,46 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int n, int cond)
+{
+  size_t vl;
+  switch (cond)
+  {
+  case 1:
+    vl = 100;
+    break;
+  case 2:
+    vl = *(size_t*)(in + 100);
+    break;
+  case 3:
+    {
+      size_t new_vl = *(size_t*)(in + 500);
+      size_t new_vl2 = *(size_t*)(in + 600);
+      vl = new_vl + new_vl2 + 777;
+      break;
+    }
+  default:
+    vl = vl + 4000;
+    break;
+  }
+  for (size_t i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i, vl);
+      __riscv_vse8_v_i8mf8 (out + i, v, vl);
+      
+      vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + i + 100, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 100, v2, vl);
+    }
+  
+  for (size_t i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + 300, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 300, v, vl);
+      vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + i + 200, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 200, v2, vl);
+    }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle8\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 2 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-14.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-14.c
new file mode 100644
index 0000000..5ede182
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-14.c
@@ -0,0 +1,66 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int n, int m, int cond, int cond2)
+{
+  size_t vl;
+  switch (cond)
+  {
+  case 1:
+    vl = 100;
+    break;
+  case 2:
+    vl = *(size_t*)(in + 100);
+    break;
+  case 3:
+    {
+      size_t new_vl = *(size_t*)(in + 500);
+      size_t new_vl2 = *(size_t*)(in + 600);
+      vl = new_vl + new_vl2 + 777;
+      break;
+    }
+  default:
+    vl = 4000;
+    break;
+  }
+  for (size_t i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i, vl);
+      __riscv_vse8_v_i8mf8 (out + i, v, vl);
+      
+      vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + i + 100, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 100, v2, vl);
+    }
+  
+  size_t vl2;
+  switch (cond)
+  {
+  case 1:
+    vl2 = 100;
+    break;
+  case 2:
+    vl2 = *(size_t*)(in + 100);
+    break;
+  case 3:
+    {
+      size_t new_vl = *(size_t*)(in + 500);
+      size_t new_vl2 = *(size_t*)(in + 600);
+      vl2 = new_vl + new_vl2 + 777;
+      break;
+    }
+  default:
+  vl2 = 4000;
+    break;
+  }
+
+  for (size_t i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + 300, vl2);
+      __riscv_vse8_v_i8mf8 (out + i + 300, v, vl2);
+      vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + i + 200, vl2);
+      __riscv_vse8_v_i8mf8 (out + i + 200, v2, vl2);
+    }
+}
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-Os" no-opts "-O1" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-15.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-15.c
new file mode 100644
index 0000000..884d69c
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-15.c
@@ -0,0 +1,67 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int n, int m, int cond, int cond2)
+{
+  size_t vl;
+  switch (cond)
+  {
+  case 1:
+    vl = 100;
+    break;
+  case 2:
+    vl = *(size_t*)(in + 100);
+    break;
+  case 3:
+    {
+      size_t new_vl = *(size_t*)(in + 500);
+      size_t new_vl2 = *(size_t*)(in + 600);
+      vl = new_vl + new_vl2 + 777;
+      break;
+    }
+  default:
+    vl = 4000;
+    break;
+  }
+  for (size_t i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i, vl);
+      __riscv_vse8_v_i8mf8 (out + i, v, vl);
+      
+      vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + i + 100, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 100, v2, vl);
+    }
+  
+  size_t vl2;
+  switch (cond2)
+  {
+  case 1:
+    vl2 = 100;
+    break;
+  case 2:
+    vl2 = *(size_t*)(in + 100);
+    break;
+  case 3:
+    {
+      size_t new_vl = *(size_t*)(in + 500);
+      size_t new_vl2 = *(size_t*)(in + 600);
+      vl2 = new_vl + new_vl2 + 777;
+      break;
+    }
+  default:
+    vl2 = 4000;
+    break;
+  }
+
+  for (size_t i = 0; i < m; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + 300, vl2);
+      __riscv_vse8_v_i8mf8 (out + i + 300, v, vl2);
+      vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + i + 200, vl2);
+      __riscv_vse8_v_i8mf8 (out + i + 200, v2, vl2);
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-Os" no-opts "-O1" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-16.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-16.c
new file mode 100644
index 0000000..c8352bb
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-16.c
@@ -0,0 +1,67 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int n, int m, int cond, int cond2)
+{
+  size_t vl;
+  switch (cond)
+  {
+  case 1:
+    vl = 100;
+    break;
+  case 2:
+    vl = *(size_t*)(in + 100);
+    break;
+  case 3:
+    {
+      size_t new_vl = *(size_t*)(in + 500);
+      size_t new_vl2 = *(size_t*)(in + 600);
+      vl = new_vl + new_vl2 + 777;
+      break;
+    }
+  default:
+    vl = 4000;
+    break;
+  }
+  for (size_t i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i, vl);
+      __riscv_vse8_v_i8mf8 (out + i, v, vl);
+      
+      vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + i + 100, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 100, v2, vl);
+    }
+  
+  size_t vl2;
+  switch (cond)
+  {
+  case 1:
+    vl2 = 100;
+    break;
+  case 2:
+    vl2 = *(size_t*)(in + 100);
+    break;
+  case 3:
+    {
+      size_t new_vl = *(size_t*)(in + 500);
+      size_t new_vl2 = *(size_t*)(in + 600);
+      vl2 = new_vl + new_vl2 + 777;
+      break;
+    }
+  default:
+  vl = 3000;
+    break;
+  }
+
+  for (size_t i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + 300, vl2);
+      __riscv_vse8_v_i8mf8 (out + i + 300, v, vl2);
+      vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + i + 200, vl2);
+      __riscv_vse8_v_i8mf8 (out + i + 200, v2, vl2);
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]} 2 { target { no-opts "-O0" no-opts "-Os" no-opts "-O1" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-2.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-2.c
new file mode 100644
index 0000000..9c0af9a
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-2.c
@@ -0,0 +1,35 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int n, int cond)
+{
+  size_t vl;
+  switch (cond)
+  {
+  case 1:
+    vl = 100;
+    break;
+  case 2:
+    vl = *(size_t*)(in + 100);
+    break;
+  case 3:
+    {
+      size_t new_vl = *(size_t*)(in + 500);
+      size_t new_vl2 = *(size_t*)(in + 600);
+      vl = new_vl + new_vl2 + 777;
+      break;
+    }
+  default:
+    break;
+  }
+  for (int i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i, vl);
+      __riscv_vse8_v_i8mf8 (out + i, v, vl);
+    }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle8\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]} { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-3.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-3.c
new file mode 100644
index 0000000..a396388
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-3.c
@@ -0,0 +1,39 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int l, int n, int m, int cond)
+{
+  size_t vl;
+  switch (cond)
+  {
+  case 1:
+    vl = 100;
+    break;
+  case 2:
+    vl = *(size_t*)(in + 100);
+    break;
+  case 3:
+    {
+      size_t new_vl = *(size_t*)(in + 500);
+      size_t new_vl2 = *(size_t*)(in + 600);
+      vl = new_vl + new_vl2 + 777;
+      break;
+    }
+  default:
+    vl = vl + 4000;
+    break;
+  }
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j, vl);
+          __riscv_vse8_v_i8mf8 (out + i + j, v, vl);
+        }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle8\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-4.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-4.c
new file mode 100644
index 0000000..f41ddb7
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-4.c
@@ -0,0 +1,38 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int l, int n, int m, int cond)
+{
+  size_t vl;
+  switch (cond)
+  {
+  case 1:
+    vl = 100;
+    break;
+  case 2:
+    vl = *(size_t*)(in + 100);
+    break;
+  case 3:
+    {
+      size_t new_vl = *(size_t*)(in + 500);
+      size_t new_vl2 = *(size_t*)(in + 600);
+      vl = new_vl + new_vl2 + 777;
+      break;
+    }
+  default:
+    break;
+  }
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j, vl);
+          __riscv_vse8_v_i8mf8 (out + i + j, v, vl);
+        }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle8\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-5.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-5.c
new file mode 100644
index 0000000..374b7af
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-5.c
@@ -0,0 +1,40 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int l, int n, int m, int cond)
+{
+  size_t vl;
+  switch (cond)
+  {
+  case 1:
+    vl = 100;
+    break;
+  case 2:
+    vl = *(size_t*)(in + 100);
+    break;
+  case 3:
+    {
+      size_t new_vl = *(size_t*)(in + 500);
+      size_t new_vl2 = *(size_t*)(in + 600);
+      vl = new_vl + new_vl2 + 777;
+      break;
+    }
+  default:
+    vl = vl + 4000;
+    break;
+  }
+  for (int i = 0; i < l; i++){
+    vl++;
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j, vl);
+          __riscv_vse8_v_i8mf8 (out + i + j, v, vl);
+        }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-6.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-6.c
new file mode 100644
index 0000000..efd1e4e
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-6.c
@@ -0,0 +1,40 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int l, int n, int m, int cond)
+{
+  size_t vl;
+  switch (cond)
+  {
+  case 1:
+    vl = 100;
+    break;
+  case 2:
+    vl = *(size_t*)(in + 100);
+    break;
+  case 3:
+    {
+      size_t new_vl = *(size_t*)(in + 500);
+      size_t new_vl2 = *(size_t*)(in + 600);
+      vl = new_vl + new_vl2 + 777;
+      break;
+    }
+  default:
+    break;
+  }
+  for (int i = 0; i < l; i++){
+    vl++;
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j, vl);
+          __riscv_vse8_v_i8mf8 (out + i + j, v, vl);
+        }
+    }
+  }
+}
+
+
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-7.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-7.c
new file mode 100644
index 0000000..2e1f68f
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-7.c
@@ -0,0 +1,40 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int l, int n, int m, int cond)
+{
+  size_t vl;
+  switch (cond)
+  {
+  case 1:
+    vl = 100;
+    break;
+  case 2:
+    vl = *(size_t*)(in + 100);
+    break;
+  case 3:
+    {
+      size_t new_vl = *(size_t*)(in + 500);
+      size_t new_vl2 = *(size_t*)(in + 600);
+      vl = new_vl + new_vl2 + 777;
+      break;
+    }
+  default:
+    vl = vl + 4000;
+    break;
+  }
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j, vl);
+          __riscv_vse8_v_i8mf8 (out + i + j, v, vl);
+        }
+    }
+    vl++;
+  }
+}
+
+/* { dg-final { scan-assembler {add\s+\s*[a-x0-9]+,\s*[a-x0-9]+,\s*[a-x0-9]+\s+vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]} { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-8.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-8.c
new file mode 100644
index 0000000..a3dca38
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-8.c
@@ -0,0 +1,39 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int l, int n, int m, int cond)
+{
+  size_t vl;
+  switch (cond)
+  {
+  case 1:
+    vl = 100;
+    break;
+  case 2:
+    vl = *(size_t*)(in + 100);
+    break;
+  case 3:
+    {
+      size_t new_vl = *(size_t*)(in + 500);
+      size_t new_vl2 = *(size_t*)(in + 600);
+      vl = new_vl + new_vl2 + 777;
+      break;
+    }
+  default:
+    break;
+  }
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j, vl);
+          __riscv_vse8_v_i8mf8 (out + i + j, v, vl);
+        }
+    }
+    vl++;
+  }
+}
+
+/* { dg-final { scan-assembler {add\s+\s*[a-x0-9]+,\s*[a-x0-9]+,\s*[a-x0-9]+\s+vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]} { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-9.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-9.c
new file mode 100644
index 0000000..60d3f09
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_multiple-9.c
@@ -0,0 +1,74 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int l, int n, int m, int cond)
+{
+  size_t vl;
+  switch (cond)
+  {
+  case 1:
+    vl = 100;
+    break;
+  case 2:
+    vl = *(size_t*)(in + 100);
+    break;
+  case 3:
+    {
+      size_t new_vl = *(size_t*)(in + 500);
+      size_t new_vl2 = *(size_t*)(in + 600);
+      vl = new_vl + new_vl2 + 777;
+      break;
+    }
+  default:
+    vl = vl + 4000;
+    break;
+  }
+  for (int i = 0; i < n; i++)
+    {
+      vint8mf8_t v1 = __riscv_vle8_v_i8mf8 (in + i + 1, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 1, v1, vl);
+
+      vint8mf8_t v2 = __riscv_vle8_v_i8mf8 (in + i + 2, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 2, v2, vl);
+
+      vint8mf8_t v3 = __riscv_vle8_v_i8mf8 (in + i + 3, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 3, v3, vl);
+
+      vint8mf8_t v4 = __riscv_vle8_v_i8mf8 (in + i + 4, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 4, v4, vl);
+
+      vint8mf8_t v5 = __riscv_vle8_v_i8mf8 (in + i + 5, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 5, v5, vl);
+
+      vint8mf8_t v6 = __riscv_vle8_v_i8mf8 (in + i + 6, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 6, v6, vl);
+
+      vint8mf8_t v7 = __riscv_vle8_v_i8mf8 (in + i + 7, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 7, v7, vl);
+
+      vint8mf8_t v8 = __riscv_vle8_v_i8mf8 (in + i + 8, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 8, v8, vl);
+
+      vint8mf8_t v9 = __riscv_vle8_v_i8mf8 (in + i + 9, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 9, v9, vl);
+
+      vint8mf8_t v10 = __riscv_vle8_v_i8mf8 (in + i + 10, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 10, v10, vl);
+
+      vint8mf8_t v11 = __riscv_vle8_v_i8mf8 (in + i + 11, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 11, v11, vl);
+
+      vint8mf8_t v12 = __riscv_vle8_v_i8mf8 (in + i + 12, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 12, v12, vl);
+
+      vint8mf8_t v13 = __riscv_vle8_v_i8mf8 (in + i + 13, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 13, v13, vl);
+
+      vint8mf8_t v14 = __riscv_vle8_v_i8mf8 (in + i + 14, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 14, v14, vl);
+    }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+add\s+\s*[a-x0-9]+,\s*[a-x0-9]+,\s*[a-x0-9]+\s+vle8\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-1.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-1.c
new file mode 100644
index 0000000..84225db
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-1.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int n, int vl)
+{
+  for (int i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i, vl);
+      __riscv_vse8_v_i8mf8 (out + i, v, vl);
+    }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle8\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-10.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-10.c
new file mode 100644
index 0000000..f64d1c3
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-10.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int n)
+{
+  size_t vl = 39;
+  for (int i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i, vl);
+      __riscv_vse8_v_i8mf8 (out + i, v, vl);
+      
+      vint8mf2_t v2 = __riscv_vle8_v_i8mf2 (in + i + 100, vl);
+      __riscv_vse8_v_i8mf2 (out + i + 100, v2, vl);
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-11.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-11.c
new file mode 100644
index 0000000..e1a8383
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-11.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int n)
+{
+  size_t vl = 39;
+  for (int i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i, vl);
+      __riscv_vse8_v_i8mf8 (out + i, v, vl);
+      
+      vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + i + 100, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 100, v2, vl);
+    }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle8\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-12.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-12.c
new file mode 100644
index 0000000..027bc38
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-12.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int n, int cond)
+{
+  if (cond == 2) {
+    size_t vl = 101;
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + 900, vl);
+    __riscv_vse8_v_i8mf8 (out + 900, v, vl);
+    vl = 102;
+    vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + 1000, vl);
+    __riscv_vse8_v_i8mf8 (out + 1000, v2, vl);
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-13.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-13.c
new file mode 100644
index 0000000..faf6895
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-13.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int n, int cond)
+{
+  size_t vl = 101;
+  for (size_t i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i, vl);
+      __riscv_vse8_v_i8mf8 (out + i, v, vl);
+      
+      vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + i + 100, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 100, v2, vl);
+    }
+  
+  for (size_t i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + 300, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 300, v, vl);
+      vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + i + 200, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 200, v2, vl);
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-14.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-14.c
new file mode 100644
index 0000000..4267543
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-14.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int n, int cond)
+{
+  size_t vl = 101;
+  
+  for (size_t i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i, vl);
+      __riscv_vse8_v_i8mf8 (out + i, v, vl);
+      
+      vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + i + 100, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 100, v2, vl);
+    }
+    
+  for (size_t i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + 300, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 300, v, vl);
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-15.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-15.c
new file mode 100644
index 0000000..501e076
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-15.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int n, int cond)
+{
+  size_t vl = 101;
+  
+  for (size_t i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + 300, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 300, v, vl);
+    }
+
+  for (size_t i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i, vl);
+      __riscv_vse8_v_i8mf8 (out + i, v, vl);
+      
+      vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + i + 100, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 100, v2, vl);
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-16.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-16.c
new file mode 100644
index 0000000..75bed40
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-16.c
@@ -0,0 +1,32 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int n, int m, int cond)
+{
+  size_t vl = 101;
+  vbool64_t mask = *(vbool64_t*) (in + 1000000);
+  for (size_t j = 0; j < m; j++){
+    for (size_t i = 0; i < n; i++)
+      {
+        vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j, vl);
+        __riscv_vse8_v_i8mf8 (out + i, v, vl);
+        
+        vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tumu (mask, v, in + i + j + 100, vl);
+        __riscv_vse8_v_i8mf8_m (mask, out + i + j + 100, v2, vl);
+      }
+      
+    for (size_t i = 0; i < n; i++)
+      {
+        vfloat32mf2_t v = __riscv_vle32_v_f32mf2 ((float *)(in + i + j + 200), vl);
+        __riscv_vse32_v_f32mf2 ((float *)(out + i + j + 200), v, vl);
+        
+        vfloat32mf2_t v2 = __riscv_vle32_v_f32mf2_tumu (mask, v, (float *)(in + i + j + 300), vl);
+        __riscv_vse32_v_f32mf2_m (mask, (float *)(out + i + j + 300), v2, vl);
+      }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-17.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-17.c
new file mode 100644
index 0000000..ad2b340
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-17.c
@@ -0,0 +1,29 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int n, int m, int cond)
+{
+  size_t vl = 101;
+  vbool64_t mask = *(vbool64_t*) (in + 1000000);
+  for (size_t j = 0; j < m; j++){
+    for (size_t i = 0; i < n; i++)
+      {
+        vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j, vl);
+        __riscv_vse8_v_i8mf8 (out + i, v, vl);
+      }
+      
+    for (size_t i = 0; i < n; i++)
+      {
+        vfloat32mf2_t v = __riscv_vle32_v_f32mf2 ((float *)(in + i + j + 200), vl);
+        __riscv_vse32_v_f32mf2 ((float *)(out + i + j + 200), v, vl);
+        
+        vfloat32mf2_t v2 = __riscv_vle32_v_f32mf2_tumu (mask, v, (float *)(in + i + j + 300), vl);
+        __riscv_vse32_v_f32mf2_m (mask, (float *)(out + i + j + 300), v2, vl);
+      }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-18.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-18.c
new file mode 100644
index 0000000..3860c6d
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-18.c
@@ -0,0 +1,29 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int n, int m, int cond)
+{
+  size_t vl = 101;
+  vbool64_t mask = *(vbool64_t*) (in + 1000000);
+  for (size_t j = 0; j < m; j++){
+    for (size_t i = 0; i < n; i++)
+      {
+        vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j, vl);
+        __riscv_vse8_v_i8mf8 (out + i, v, vl);
+        
+        vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tumu (mask, v, in + i + j + 100, vl);
+        __riscv_vse8_v_i8mf8_m (mask, out + i + j + 100, v2, vl);
+      }
+      
+    for (size_t i = 0; i < n; i++)
+      {
+        vfloat32mf2_t v = __riscv_vle32_v_f32mf2 ((float *)(in + i + j + 200), vl);
+        __riscv_vse32_v_f32mf2 ((float *)(out + i + j + 200), v, vl);
+      }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-19.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-19.c
new file mode 100644
index 0000000..350e1d0
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-19.c
@@ -0,0 +1,40 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2 -fno-tree-vectorize" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int n, int m, int cond)
+{
+  size_t vl = 101;
+  vbool64_t mask = *(vbool64_t*) (in + 1000000);
+  for (size_t j = 0; j < m; j++){
+    for (size_t i = 0; i < n; i++)
+      {
+        vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j, vl);
+        __riscv_vse8_v_i8mf8 (out + i, v, vl);
+      }
+
+    for (size_t i = 0; i < n * n; i++)
+      out[i] = out[i] * out[i];
+    for (size_t i = 0; i < n * n * n; i++)
+      out[i] = out[i] + out[i];
+    for (size_t i = 0; i < n * n * n * n; i++)
+      out[i] = out[i] + 2;
+    for (size_t i = 0; i < n * n * n * n * n; i++)
+      out[i] = out[i] * 100;
+    for (size_t i = 0; i < n * n * n * n * n * n; i++)
+      out[i] = out[i] - 77;
+  
+    for (size_t i = 0; i < n; i++)
+      {
+        vfloat32mf2_t v = __riscv_vle32_v_f32mf2 ((float *)(in + i + j + 200), vl);
+        __riscv_vse32_v_f32mf2 ((float *)(out + i + j + 200), v, vl);
+        
+        vfloat32mf2_t v2 = __riscv_vle32_v_f32mf2_tumu (mask, v, (float *)(in + i + j + 300), vl);
+        __riscv_vse32_v_f32mf2_m (mask, (float *)(out + i + j + 300), v2, vl);
+      }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-2.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-2.c
new file mode 100644
index 0000000..aefb107
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-2.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int n, size_t vl)
+{
+  for (int i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i, vl << 3);
+      __riscv_vse8_v_i8mf8 (out + i, v, vl << 3);
+    }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle8\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {slli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-20.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-20.c
new file mode 100644
index 0000000..cda2e0e
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-20.c
@@ -0,0 +1,40 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2 -fno-tree-vectorize" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int n, int m, int cond)
+{
+  size_t vl = 101;
+  vbool64_t mask = *(vbool64_t*) (in + 1000000);
+  for (size_t j = 0; j < m; j++){
+    for (size_t i = 0; i < cond; i++)
+      {
+        vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j, vl);
+        __riscv_vse8_v_i8mf8 (out + i, v, vl);
+      }
+
+    for (size_t i = 0; i < n * n; i++)
+      out[i] = out[i] * out[i];
+    for (size_t i = 0; i < n * n * n; i++)
+      out[i] = out[i] + out[i];
+    for (size_t i = 0; i < n * n * n * n; i++)
+      out[i] = out[i] + 2;
+    for (size_t i = 0; i < n * n * n * n * n; i++)
+      out[i] = out[i] * 100;
+    for (size_t i = 0; i < n * n * n * n * n * n; i++)
+      out[i] = out[i] - 77;
+  
+    for (size_t i = 0; i < n; i++)
+      {
+        vfloat32mf2_t v = __riscv_vle32_v_f32mf2 ((float *)(in + i + j + 200), vl);
+        __riscv_vse32_v_f32mf2 ((float *)(out + i + j + 200), v, vl);
+        
+        vfloat32mf2_t v2 = __riscv_vle32_v_f32mf2_tumu (mask, v, (float *)(in + i + j + 300), vl);
+        __riscv_vse32_v_f32mf2_m (mask, (float *)(out + i + j + 300), v2, vl);
+      }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-21.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-21.c
new file mode 100644
index 0000000..d8f114c
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-21.c
@@ -0,0 +1,32 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2 -fno-tree-vectorize" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int n, int m, int cond)
+{
+  size_t vl = 101;
+  vbool64_t mask = *(vbool64_t*) (in + 1000000);
+  for (size_t j = 0; j < m; j++){
+
+    if (cond) {
+      for (size_t i = 0; i < n; i++)
+        {
+          vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j, vl);
+          __riscv_vse8_v_i8mf8 (out + i, v, vl);
+        }
+    } else {
+      for (size_t i = 0; i < n; i++)
+        {
+          vfloat32mf2_t v = __riscv_vle32_v_f32mf2 ((float *)(in + i + j + 200), vl);
+          __riscv_vse32_v_f32mf2 ((float *)(out + i + j + 200), v, vl);
+          
+          vfloat32mf2_t v2 = __riscv_vle32_v_f32mf2_tumu (mask, v, (float *)(in + i + j + 300), vl);
+          __riscv_vse32_v_f32mf2_m (mask, (float *)(out + i + j + 300), v2, vl);
+        }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-22.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-22.c
new file mode 100644
index 0000000..d5e5f5a
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-22.c
@@ -0,0 +1,42 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2 -fno-tree-vectorize" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int n, int m, int cond)
+{
+  vbool64_t mask = *(vbool64_t*) (in + 1000000);
+  for (size_t j = 0; j < m; j++){
+    
+    size_t vl = 101;
+    for (size_t i = 0; i < n; i++)
+      {
+        vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j, vl);
+        __riscv_vse8_v_i8mf8 (out + i, v, vl);
+      }
+
+    for (size_t i = 0; i < n * n; i++)
+      out[i] = out[i] * out[i];
+    for (size_t i = 0; i < n * n * n; i++)
+      out[i] = out[i] + out[i];
+    for (size_t i = 0; i < n * n * n * n; i++)
+      out[i] = out[i] + 2;
+    for (size_t i = 0; i < n * n * n * n * n; i++)
+      out[i] = out[i] * 100;
+    for (size_t i = 0; i < n * n * n * n * n * n; i++)
+      out[i] = out[i] - 77;
+    
+    vl = 101;
+    for (size_t i = 0; i < n; i++)
+      {
+        vfloat32mf2_t v = __riscv_vle32_v_f32mf2 ((float *)(in + i + j + 200), vl);
+        __riscv_vse32_v_f32mf2 ((float *)(out + i + j + 200), v, vl);
+        
+        vfloat32mf2_t v2 = __riscv_vle32_v_f32mf2_tumu (mask, v, (float *)(in + i + j + 300), vl);
+        __riscv_vse32_v_f32mf2_m (mask, (float *)(out + i + j + 300), v2, vl);
+      }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-23.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-23.c
new file mode 100644
index 0000000..6c2584c
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-23.c
@@ -0,0 +1,34 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2 -fno-tree-vectorize" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int n, int m, int cond)
+{
+  vbool64_t mask = *(vbool64_t*) (in + 1000000);
+  for (size_t j = 0; j < m; j++){
+    
+    size_t vl = 101;
+    for (size_t i = 0; i < n; i++)
+      {
+        vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j, vl);
+        __riscv_vse8_v_i8mf8 (out + i, v, vl);
+      }
+
+    vl = 102;
+    for (size_t i = 0; i < n; i++)
+      {
+        vfloat32mf2_t v = __riscv_vle32_v_f32mf2 ((float *)(in + i + j + 200), vl);
+        __riscv_vse32_v_f32mf2 ((float *)(out + i + j + 200), v, vl);
+        
+        vfloat32mf2_t v2 = __riscv_vle32_v_f32mf2_tumu (mask, v, (float *)(in + i + j + 300), vl);
+        __riscv_vse32_v_f32mf2_m (mask, (float *)(out + i + j + 300), v2, vl);
+      }
+  }
+}
+
+/* { dg-final { scan-assembler {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]} { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu} { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 4 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {li\s+[a-x0-9]+,101} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {li\s+[a-x0-9]+,102} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-24.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-24.c
new file mode 100644
index 0000000..2fd0964
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-24.c
@@ -0,0 +1,36 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2 -fno-tree-vectorize" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int n, int m, int cond)
+{
+  vbool64_t mask = *(vbool64_t*) (in + 1000000);
+  for (size_t j = 0; j < m; j++){
+    
+    size_t vl = 101;
+    for (size_t i = 0; i < n; i++)
+      {
+        vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j, vl);
+        __riscv_vse8_v_i8mf8 (out + i, v, vl);
+      }
+
+    for (size_t i = 0; i < cond; i++)
+      out[i] = out[i] * out[i];
+    
+    vl = 102;
+    for (size_t i = 0; i < n; i++)
+      {
+        vfloat32mf2_t v = __riscv_vle32_v_f32mf2 ((float *)(in + i + j + 200), vl);
+        __riscv_vse32_v_f32mf2 ((float *)(out + i + j + 200), v, vl);
+        
+        vfloat32mf2_t v2 = __riscv_vle32_v_f32mf2_tumu (mask, v, (float *)(in + i + j + 300), vl);
+        __riscv_vse32_v_f32mf2_m (mask, (float *)(out + i + j + 300), v2, vl);
+      }
+  }
+}
+
+/* { dg-final { scan-assembler {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]} { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu} { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {li\s+[a-x0-9]+,101} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {li\s+[a-x0-9]+,102} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-25.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-25.c
new file mode 100644
index 0000000..cfb7d78
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-25.c
@@ -0,0 +1,38 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2 -fno-tree-vectorize" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int n, int m, int cond)
+{
+  vbool64_t mask = *(vbool64_t*) (in + 1000000);
+  size_t vl = 101;
+  for (size_t j = 0; j < m; j++){
+
+    if (cond) {
+      for (size_t i = 0; i < n; i++)
+        {
+          vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j, vl);
+          __riscv_vse8_v_i8mf8 (out + i, v, vl);
+        }
+    } else {
+      for (size_t i = 0; i < n; i++)
+        {
+          vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j + 100, vl);
+          __riscv_vse8_v_i8mf8 (out + i + 100, v, vl);
+        }
+    }
+    
+    for (size_t i = 0; i < n; i++)
+      {
+        vfloat32mf2_t v = __riscv_vle32_v_f32mf2 ((float *)(in + i + j + 200), vl);
+        __riscv_vse32_v_f32mf2 ((float *)(out + i + j + 200), v, vl);
+        
+        vfloat32mf2_t v2 = __riscv_vle32_v_f32mf2_tumu (mask, v, (float *)(in + i + j + 300), vl);
+        __riscv_vse32_v_f32mf2_m (mask, (float *)(out + i + j + 300), v2, vl);
+      }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-26.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-26.c
new file mode 100644
index 0000000..13eee21
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-26.c
@@ -0,0 +1,35 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2 -fno-tree-vectorize" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int n, int m, int cond)
+{
+  vbool64_t mask = *(vbool64_t*) (in + 1000000);
+  size_t vl = 101;
+  for (size_t j = 0; j < m; j++){
+
+    if (cond) {
+      for (size_t i = 0; i < n; i++)
+        {
+          vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j, vl);
+          __riscv_vse8_v_i8mf8 (out + i, v, vl);
+        }
+    } else {
+      for (size_t i = 0; i < cond; i++)
+        out[i] = out[i] * 33;
+    }
+    
+    for (size_t i = 0; i < n; i++)
+      {
+        vfloat32mf2_t v = __riscv_vle32_v_f32mf2 ((float *)(in + i + j + 200), vl);
+        __riscv_vse32_v_f32mf2 ((float *)(out + i + j + 200), v, vl);
+        
+        vfloat32mf2_t v2 = __riscv_vle32_v_f32mf2_tumu (mask, v, (float *)(in + i + j + 300), vl);
+        __riscv_vse32_v_f32mf2_m (mask, (float *)(out + i + j + 300), v2, vl);
+      }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-27.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-27.c
new file mode 100644
index 0000000..179fccd
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-27.c
@@ -0,0 +1,36 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2 -fno-tree-vectorize" } */
+
+#include "riscv_vector.h"
+
+void f2 (int8_t * restrict in, int8_t * restrict out, int n, int m, unsigned cond, size_t vl)
+{
+  vbool64_t mask = *(vbool64_t*) (in + 1000000);
+
+  vl = 101;
+  if (cond > 0) {
+    for (size_t i = 0; i < n; i++)
+      {
+        vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i, vl);
+        __riscv_vse8_v_i8mf8 (out + i, v, vl);
+      }
+  } else {
+    for (size_t i = 0; i < n; i++)
+      {
+        vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + 1000, vl);
+        __riscv_vse8_v_i8mf8 (out + i + 1000, v, vl);
+      }
+  }
+    
+  for (size_t i = 0; i < n; i++)
+    {
+      vfloat32mf2_t v = __riscv_vle32_v_f32mf2 ((float *)(in + i + 200), vl);
+      __riscv_vse32_v_f32mf2 ((float *)(out + i + 200), v, vl);
+      
+      vfloat32mf2_t v2 = __riscv_vle32_v_f32mf2_tumu (mask, v, (float *)(in + i + 300), vl);
+      __riscv_vse32_v_f32mf2_m (mask, (float *)(out + i + 300), v2, vl);
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu} 2 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 3 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-28.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-28.c
new file mode 100644
index 0000000..b5b3fda
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-28.c
@@ -0,0 +1,30 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2 -fno-tree-vectorize" } */
+
+#include "riscv_vector.h"
+
+void f2 (int8_t * restrict in, int8_t * restrict out, int n, int m, unsigned cond, size_t vl)
+{
+  vbool64_t mask = *(vbool64_t*) (in + 1000000);
+
+  vl = 101;
+  if (cond > 0) {
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in, vl);
+    __riscv_vse8_v_i8mf8 (out, v, vl);
+  } else {
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + 10000, vl);
+    __riscv_vse8_v_i8mf8 (out + 10000, v, vl);
+  }
+    
+  for (size_t i = 0; i < n; i++)
+    {
+      vfloat32mf2_t v = __riscv_vle32_v_f32mf2 ((float *)(in + i + 200), vl);
+      __riscv_vse32_v_f32mf2 ((float *)(out + i + 200), v, vl);
+      
+      vfloat32mf2_t v2 = __riscv_vle32_v_f32mf2_tumu (mask, v, (float *)(in + i + 300), vl);
+      __riscv_vse32_v_f32mf2_m (mask, (float *)(out + i + 300), v2, vl);
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu} 2 { target { no-opts "-O0" no-opts "-O1" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 3 { target { no-opts "-O0" no-opts "-O1" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-29.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-29.c
new file mode 100644
index 0000000..f6296e0
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-29.c
@@ -0,0 +1,31 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2 -fno-tree-vectorize" } */
+
+#include "riscv_vector.h"
+
+void f2 (int8_t * restrict in, int8_t * restrict out, int n, int m, unsigned cond, size_t vl)
+{
+  vbool64_t mask = *(vbool64_t*) (in + 1000000);
+
+  vl = 101;
+  if (cond > 0) {
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in, vl);
+    __riscv_vse8_v_i8mf8 (out, v, vl);
+  } else {
+    vint16mf4_t v = __riscv_vle16_v_i16mf4 ((int16_t *)(in + 10000), vl);
+    __riscv_vse16_v_i16mf4 ((int16_t *)(out + 10000), v, vl);
+  }
+    
+  for (size_t i = 0; i < n; i++)
+    {
+      vfloat32mf2_t v = __riscv_vle32_v_f32mf2 ((float *)(in + i + 200), vl);
+      __riscv_vse32_v_f32mf2 ((float *)(out + i + 200), v, vl);
+      
+      vfloat32mf2_t v2 = __riscv_vle32_v_f32mf2_tumu (mask, v, (float *)(in + i + 300), vl);
+      __riscv_vse32_v_f32mf2_m (mask, (float *)(out + i + 300), v2, vl);
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu} 2 { target { no-opts "-O0" no-opts "-O1" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 3 { target { no-opts "-O0" no-opts "-O1" no-opts "-g" no-opts "-funroll-loops" } } } } */
+
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-3.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-3.c
new file mode 100644
index 0000000..68505ca
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-3.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int n, size_t vl)
+{
+  vl = vl << 3;
+  for (int i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i, vl);
+      __riscv_vse8_v_i8mf8 (out + i, v, vl);
+    }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle8\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {slli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-30.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-30.c
new file mode 100644
index 0000000..b5267b7
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-30.c
@@ -0,0 +1,29 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2 -fno-tree-vectorize" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int n, int m, unsigned cond, size_t vl)
+{
+  vbool64_t mask = *(vbool64_t*) (in + 1000000);
+
+  vl = 101;
+  if (cond > 0) {
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in, vl);
+    __riscv_vse8_v_i8mf8 (out, v, vl);
+  } else {
+    out[100] = out[100] + 300;
+  }
+    
+  for (size_t i = 0; i < n; i++)
+    {
+      vfloat32mf2_t v = __riscv_vle32_v_f32mf2 ((float *)(in + i + 200), vl);
+      __riscv_vse32_v_f32mf2 ((float *)(out + i + 200), v, vl);
+      
+      vfloat32mf2_t v2 = __riscv_vle32_v_f32mf2_tumu (mask, v, (float *)(in + i + 300), vl);
+      __riscv_vse32_v_f32mf2_m (mask, (float *)(out + i + 300), v2, vl);
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu} 2 { target { no-opts "-O0" no-opts "-Os" no-opts "-O1" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 3 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-31.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-31.c
new file mode 100644
index 0000000..9afa547
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-31.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2 -fno-tree-vectorize" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int n, int cond)
+{
+  size_t vl = *(size_t*)(in + 10000);
+  
+  for (size_t i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + 300, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 300, v, vl);
+    }
+
+  for (size_t i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i, vl);
+      __riscv_vse8_v_i8mf8 (out + i, v, vl);
+      
+      vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + i + 100, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 100, v2, vl);
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-32.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-32.c
new file mode 100644
index 0000000..31363d2
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-32.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2 -fno-tree-vectorize" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int n, int cond)
+{
+  size_t vl = ((cond + 100) * cond) >> 3;
+  
+  for (size_t i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + 300, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 300, v, vl);
+    }
+  
+  for (size_t i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i, vl);
+      __riscv_vse8_v_i8mf8 (out + i, v, vl);
+      
+      vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + i + 100, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 100, v2, vl);
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-33.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-33.c
new file mode 100644
index 0000000..f4f58cd
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-33.c
@@ -0,0 +1,29 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2 -fno-tree-vectorize" } */
+
+#include "riscv_vector.h"
+
+char fn3 (void);
+
+void f (int8_t * restrict in, int8_t * restrict out, int n, int cond)
+{
+  size_t vl = fn3 ();
+  
+  for (size_t i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + 300, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 300, v, vl);
+    }
+  
+  for (size_t i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i, vl);
+      __riscv_vse8_v_i8mf8 (out + i, v, vl);
+      
+      vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + i + 100, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 100, v2, vl);
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-34.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-34.c
new file mode 100644
index 0000000..d28c12b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-34.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2 -fno-tree-vectorize" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int n, int cond)
+{
+  size_t vl;
+  asm volatile ("li %0, 101" :"=r" (vl)::"memory");
+  
+  for (size_t i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + 300, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 300, v, vl);
+    }
+  
+  for (size_t i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i, vl);
+      __riscv_vse8_v_i8mf8 (out + i, v, vl);
+      
+      vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + i + 100, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 100, v2, vl);
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-35.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-35.c
new file mode 100644
index 0000000..2823091
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-35.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2 -fno-tree-vectorize" } */
+
+#include "riscv_vector.h"
+
+static int vl = 0x5545515;
+
+void f (int8_t * restrict in, int8_t * restrict out, int n, int cond)
+{
+  for (size_t i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + 300, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 300, v, vl);
+    }
+  
+  for (size_t i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i, vl);
+      __riscv_vse8_v_i8mf8 (out + i, v, vl);
+      
+      vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + i + 100, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 100, v2, vl);
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-36.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-36.c
new file mode 100644
index 0000000..3c93675
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-36.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2 -fno-tree-vectorize" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int n, int cond)
+{
+  for (size_t i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + 300,555);
+      __riscv_vse8_v_i8mf8 (out + i + 300, v,555);
+    }
+
+  for (size_t i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i,555);
+      __riscv_vse8_v_i8mf8 (out + i, v,555);
+      
+      vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + i + 100,555);
+      __riscv_vse8_v_i8mf8 (out + i + 100, v2,555);
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-37.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-37.c
new file mode 100644
index 0000000..0c6a251
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-37.c
@@ -0,0 +1,29 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2 -fno-tree-vectorize" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int n, int m, unsigned cond, size_t vl)
+{
+  asm volatile ("li %0, 101" :"=r" (vl)::"memory");
+  vbool64_t mask = *(vbool64_t*) (in + 1000000);
+  if (cond > 0) {
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in, vl);
+    __riscv_vse8_v_i8mf8 (out, v, vl);
+  } else {
+    out[100] = out[100] + 300;
+  }
+    
+  for (size_t i = 0; i < n; i++)
+    {
+      vfloat32mf2_t v = __riscv_vle32_v_f32mf2 ((float *)(in + i + 200), vl);
+      __riscv_vse32_v_f32mf2 ((float *)(out + i + 200), v, vl);
+      
+      vfloat32mf2_t v2 = __riscv_vle32_v_f32mf2_tumu (mask, v, (float *)(in + i + 300), vl);
+      __riscv_vse32_v_f32mf2_m (mask, (float *)(out + i + 300), v2, vl);
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu} 2 { target { no-opts "-O0" no-opts "-O1" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 3 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+addi\s+\s*[a-x0-9]+,\s*[a-x0-9]+,\s*[0-9]00\s+addi\s+\s*[a-x0-9]+,\s*[a-x0-9]+,\s*[0-9]00\s+addi\s+\s*[a-x0-9]+,\s*[a-x0-9]+,\s*[0-9]00\s+add\s+\s*[a-x0-9]+,\s*[a-x0-9]+,\s*[a-x0-9]+\s+\.L[0-9]+\:} 1 { target { no-opts "-O0" no-opts "-O1" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-38.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-38.c
new file mode 100644
index 0000000..ba90e79
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-38.c
@@ -0,0 +1,57 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int8_t * restrict out2, int n, int m, unsigned cond, size_t vl)
+{
+  vl = 22;
+  vbool64_t mask = *(vbool64_t*) (in + 1000000);
+  if (cond == 0) {
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in, vl);
+    __riscv_vse8_v_i8mf8 (out, v, vl);
+  } else {
+    out2[100] = out2[100] + 300;
+  }
+
+  for (size_t i = 0; i < n; i++)
+    out[i + 200] = out[i + 500] + 22;
+
+  for (size_t i = 0; i < n; i++)
+    {
+      vfloat32mf2_t v = __riscv_vle32_v_f32mf2 ((float *)(in + i + 200), 22);
+      __riscv_vse32_v_f32mf2 ((float *)(out + i + 200), v, 22);
+      
+      vfloat32mf2_t v2 = __riscv_vle32_v_f32mf2_tumu (mask, v, (float *)(in + i + 300), 22);
+      __riscv_vse32_v_f32mf2_m (mask, (float *)(out + i + 300), v2, 22);
+    }
+}
+
+void f2 (int8_t * restrict in, int8_t * restrict out, int n, int m, unsigned cond, size_t vl)
+{
+  asm volatile ("li %0, 101" :"=r" (vl)::"memory");
+  vbool64_t mask = *(vbool64_t*) (in + 1000000);
+  if (cond > 0) {
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in, vl);
+    __riscv_vse8_v_i8mf8 (out, v, vl);
+  } else {
+    out[100] = out[100] + 300;
+  }
+
+  for (size_t i = 0; i < n; i++)
+    out[i + 200] = out[i + 500] + 555;
+
+  for (size_t i = 0; i < n; i++)
+    {
+      vfloat32mf2_t v = __riscv_vle32_v_f32mf2 ((float *)(in + i + 200), vl);
+      __riscv_vse32_v_f32mf2 ((float *)(out + i + 200), v, vl);
+      
+      vfloat32mf2_t v2 = __riscv_vle32_v_f32mf2_tumu (mask, v, (float *)(in + i + 300), vl);
+      __riscv_vse32_v_f32mf2_m (mask, (float *)(out + i + 300), v2, vl);
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,22,\s*e32,\s*mf2,\s*tu,\s*mu} 2 { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu} 2 { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 4 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli} 2 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-39.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-39.c
new file mode 100644
index 0000000..06f57dc
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-39.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t *base, int8_t *out, size_t m, size_t n) {
+  int vl = 101;
+  for (size_t i = 0; i < m; i++) {
+    vint8mf8_t v0 = __riscv_vle8_v_i8mf8_tu(v0, base + i, vl);
+    if (n > 100) {
+      __riscv_vse8_v_i8mf8(out + i + 100, v0, vl);
+    } else {
+      __riscv_vse8_v_i8mf8(out + i, v0, vl);
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-O1" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-4.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-4.c
new file mode 100644
index 0000000..4fd3ece
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-4.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int l, int n, int m, size_t vl)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j, vl);
+          __riscv_vse8_v_i8mf8 (out + i + j, v, vl);
+        }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle8\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-40.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-40.c
new file mode 100644
index 0000000..796b40f
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-40.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t *base, int8_t *out, size_t m, size_t n) {
+  for (size_t i = 0; i < m; i++) {
+    for (size_t j = 0; j < n; j += 1) {
+      vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i, j);
+      v0 = __riscv_vle8_v_i8mf8_tu(v0, base + i + 100, j);
+      __riscv_vse8_v_i8mf8(out + i, v0, j);
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0" no-opts "-O1" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-41.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-41.c
new file mode 100644
index 0000000..0589eba
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-41.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t *base, int8_t *out, size_t m, size_t n) {
+  int vl = 101;
+  for (size_t i = 0; i < m; i++) {
+    vint8mf8_t v0 = __riscv_vle8_v_i8mf8_tu(v0, base + i, vl);
+    if (n > 100) {
+      __riscv_vse8_v_i8mf8(out + i + 100, v0, vl);
+    } else {
+      __riscv_vse8_v_i8mf8(out + i, v0, vl);
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-42.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-42.c
new file mode 100644
index 0000000..b5ffcbe
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-42.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t *base, int8_t *out, size_t m, size_t n) {
+  for (size_t i = 0; i < m; i++) {
+    for (size_t j = 0; j < n; j += 1) {
+      vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i, i);
+      v0 = __riscv_vle8_v_i8mf8_tu(v0, base + i + 100, i);
+      __riscv_vse8_v_i8mf8(out + i, v0, i);
+    }
+  }
+}
+/* { dg-final { scan-assembler {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]\s+\.L[0-9]+\:\s+vle8\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-43.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-43.c
new file mode 100644
index 0000000..44488aa
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-43.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f(int8_t *base, int8_t *out, size_t vl, size_t m) {
+  vbool64_t mask = *(vbool64_t*) (base + 10000);
+  for (size_t i = 0; i < m; i++) {
+    vint8mf8_t v0 = __riscv_vle8_v_i8mf8_mu(mask, v0, base + i, vl);
+    __riscv_vse8_v_i8mf8(out + i, v0, vl);
+  }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle8\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\),v0\.t} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*mu} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-44.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-44.c
new file mode 100644
index 0000000..470c99e
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-44.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f(int8_t *base, int8_t *out, size_t vl, size_t m) {
+  vbool64_t mask = *(vbool64_t*) (base + 10000);
+  vint8mf8_t v0;
+  for (size_t i = 0; i < m; i++) {
+    if (i % 2 == 0) {
+      v0 = __riscv_vle8_v_i8mf8_tumu(mask, v0, base + i, vl);
+    } else {
+      __riscv_vse8_v_i8mf8(out + i, v0, vl);
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-45.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-45.c
new file mode 100644
index 0000000..a2ee5ec
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-45.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void foo1_7(int8_t *base, int8_t *out, size_t vl, size_t m, size_t n, size_t o, size_t p) {
+  size_t avl = vl;
+  if (o > p) {
+    for (size_t i = 0; i < m; i++) {
+      vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i, avl);
+      v0 = __riscv_vle8_v_i8mf8_tu(v0, base + i + 100, avl);
+      __riscv_vse8_v_i8mf8(out + i, v0, avl);
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle8\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-46.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-46.c
new file mode 100644
index 0000000..1c5ee6a
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-46.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int n, int cond)
+{
+  int vl = 101;
+  if (n > cond) {
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + 600, vl);
+    vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + 600, vl);
+    __riscv_vse8_v_i8mf8 (out + 600, v2, vl);
+  } else {
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + 700, vl);
+    __riscv_vse8_v_i8mf8 (out + 700, v, vl);
+  }
+
+  for (int i = 0 ; i < n * n * n * n; i++) {
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + 900 + i, vl);
+    __riscv_vse8_v_i8mf8 (out + 900 + i, v, vl);
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-47.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-47.c
new file mode 100644
index 0000000..935e1b1
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-47.c
@@ -0,0 +1,35 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int n, int cond)
+{
+  size_t vl;
+  asm volatile ("li %0, 101" :"=r" (vl)::"memory");
+  if (n > cond) {
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + 600, cond);
+    vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + 600, cond);
+    __riscv_vse8_v_i8mf8 (out + 600, v2, cond);
+  } else {
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + 700, cond);
+    __riscv_vse8_v_i8mf8 (out + 700, v, cond);
+  }
+
+  for (int i = 0 ; i < n * n; i++)
+    out[i] = out[i] + out[i];
+  
+  for (int i = 0 ; i < n * n * n; i++)
+    out[i] = out[i] * out[i];
+
+  for (int i = 0 ; i < n * n * n * n; i++)
+    out[i] = out[i] * out[i];
+  
+  for (int i = 0 ; i < n * n * n * n; i++) {
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + 900 + i, cond);
+    __riscv_vse8_v_i8mf8 (out + 900 + i, v, cond);
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-48.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-48.c
new file mode 100644
index 0000000..319db54
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-48.c
@@ -0,0 +1,32 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int n, int n2)
+{
+  size_t vl;
+  asm volatile ("li %0, 101" :"=r" (vl)::"memory");
+  for (int i = 0 ; i < n2; i++) {
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + 800 + i, vl);
+    v = __riscv_vle8_v_i8mf8_tu (v, in + 900 + i, vl);
+    __riscv_vse8_v_i8mf8 (out + 800 + i, v, vl);
+  }
+
+  for (int i = 0 ; i < n * n; i++)
+    out[i] = out[i] + out[i];
+  
+  for (int i = 0 ; i < n * n * n; i++)
+    out[i] = out[i] * out[i];
+
+  for (int i = 0 ; i < n * n * n * n; i++)
+    out[i] = out[i] * out[i];
+  
+  for (int i = 0 ; i < n * n * n * n; i++) {
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + 900 + i, vl);
+    __riscv_vse8_v_i8mf8 (out + 900 + i, v, vl);
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]} 2 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-49.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-49.c
new file mode 100644
index 0000000..4fa6862
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-49.c
@@ -0,0 +1,32 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int n, int n2)
+{
+  size_t vl;
+  asm volatile ("li %0, 101" :"=r" (vl)::"memory");
+  for (int i = 0 ; i < n2; i++) {
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + 800 + i, vl);
+    __riscv_vse8_v_i8mf8 (out + 800 + i, v, vl);
+  }
+
+  for (int i = 0 ; i < n * n; i++)
+    out[i] = out[i] + out[i];
+  
+  for (int i = 0 ; i < n * n * n; i++)
+    out[i] = out[i] * out[i];
+
+  for (int i = 0 ; i < n * n * n * n; i++)
+    out[i] = out[i] * out[i];
+  
+  asm volatile ("li %0, 102" :"=r" (vl)::"memory");
+  for (int i = 0 ; i < n * n * n * n; i++) {
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + 900 + i, vl);
+    __riscv_vse8_v_i8mf8 (out + 900 + i, v, vl);
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-5.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-5.c
new file mode 100644
index 0000000..9980242
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-5.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int n, int vl)
+{
+  for (int i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i, vl);
+      __riscv_vse8_v_i8mf8 (out + i, v, vl);
+      vl++;
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+vle8\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-50.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-50.c
new file mode 100644
index 0000000..0c87643
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-50.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f(void *base, void *out, void *mask_in, size_t m) {
+  vbool64_t mask = *(vbool64_t*)mask_in;
+  size_t vl = 105;
+  for (size_t i = 0; i < m; i++) {
+    if (i % 2 == 0) {
+      vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i, vl);
+      vint8mf8_t v1 = __riscv_vle8_v_i8mf8_tu(v0, base + i + 100, vl);
+      __riscv_vse8_v_i8mf8 (out + i, v1, vl);
+    } else {
+      vint16mf4_t v0 = __riscv_vle16_v_i16mf4(base + i, vl);
+      vint16mf4_t v1 = __riscv_vle16_v_i16mf4_mu(mask, v0, base + i + 100, vl);
+      __riscv_vse16_v_i16mf4 (out + i, v1, vl);
+    }
+  }
+}
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu} 1 { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-51.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-51.c
new file mode 100644
index 0000000..d2ceab4
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-51.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f(void *base, void *out, void *mask_in, size_t m, size_t n) {
+  vbool64_t mask = *(vbool64_t*)mask_in;
+  size_t vl = 106;
+  for (size_t i = 0; i < m; i++) {
+    for (size_t j = 0; j < n; j++){
+      if ((i + j) % 2 == 0) {
+        vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + j, vl);
+        vint8mf8_t v1 = __riscv_vle8_v_i8mf8_tu(v0, base + i + j + 100, vl);
+        __riscv_vse8_v_i8mf8 (out + i + j, v1, vl);
+      } else {
+        vint16mf4_t v0 = __riscv_vle16_v_i16mf4(base + i + j, vl);
+        vint16mf4_t v1 = __riscv_vle16_v_i16mf4_mu(mask, v0, base + i + j + 100, vl);
+        __riscv_vse16_v_i16mf4 (out + i + j, v1, vl);
+      }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*mu} 1 { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-52.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-52.c
new file mode 100644
index 0000000..882576e
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-52.c
@@ -0,0 +1,34 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f(void *base, void *out, void *mask_in, size_t m, size_t n) {
+  
+  size_t vl = 107;
+  for (size_t i = 0; i < m; i++) {
+    if (i % 2 == 0) {
+      for (size_t j = 0; j < n; j++){
+        vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + j + 700, vl);
+        vint8mf8_t v1 = __riscv_vle8_v_i8mf8_tu(v0, base + i + j + 700, vl);
+        __riscv_vse8_v_i8mf8 (out + i + j + 700, v1, vl);
+        if (j % 2 == 0) {
+          vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + j + 500, vl);
+          __riscv_vse8_v_i8mf8 (out + i + j + 500, v0, vl);
+        } else {
+          vint16mf4_t v0 = __riscv_vle16_v_i16mf4(base + i + j + 600, vl);
+          __riscv_vse16_v_i16mf4 (out + i + j + 600, v0, vl);
+        }
+      }
+    } else {
+      for (size_t j = 0; j < n; j++){
+        vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + j + 200, vl);
+        vint8mf8_t v1 = __riscv_vle8_v_i8mf8_tu(v0, base + i + j + 300, vl);
+        __riscv_vse8_v_i8mf8 (out + i + j + 400, v1, vl);
+      }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-53.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-53.c
new file mode 100644
index 0000000..dbdb025
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-53.c
@@ -0,0 +1,31 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f(void *base, void *out, void *mask_in, size_t m, size_t n) {
+
+  size_t vl = 222;
+  for (size_t i = 0; i < m; i++) {
+    if (i % 2 == 0) {
+      for (size_t j = 0; j < n; j++){
+        if (j % 2 == 0) {
+          vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + j + 500, vl);
+          __riscv_vse8_v_i8mf8 (out + i + j + 500, v0, vl);
+        } else {
+          vint16mf4_t v0 = __riscv_vle16_v_i16mf4(base + i + j + 600, vl);
+          __riscv_vse16_v_i16mf4 (out + i + j + 600, v0, vl);
+        }
+      }
+    } else {
+      for (size_t j = 0; j < n; j++){
+        vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + j + 200, vl);
+        vint8mf8_t v1 = __riscv_vle8_v_i8mf8_tu(v0, base + i + j + 300, vl);
+        __riscv_vse8_v_i8mf8 (out + i + j + 400, v1, vl);
+      }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-54.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-54.c
new file mode 100644
index 0000000..7b85cc7
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-54.c
@@ -0,0 +1,32 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f(void *base, void *out, void *mask_in, size_t m, size_t n) {
+  
+  size_t vl = 333;
+  for (size_t i = 0; i < m; i++) {
+    if (i % 2 == 0) {
+      for (size_t j = 0; j < n; j++){
+        if (j % 2 == 0) {
+          vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 200, vl);
+          vint8mf8_t v1 = __riscv_vle8_v_i8mf8_tu(v0, base + i + 200, vl);
+          __riscv_vse8_v_i8mf8 (out + i + 200, v1, vl);
+        } else {
+          vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 300, vl);
+          vint8mf8_t v1 = __riscv_vle8_v_i8mf8_tu(v0, base + i + 300, vl);
+          __riscv_vse8_v_i8mf8 (out + i + 300, v1, vl);
+        }
+      }
+    } else {
+      for (size_t j = 0; j < n; j++){
+        vint8mf8_t v1 = __riscv_vle8_v_i8mf8(base + i + j + 300, vl);
+        __riscv_vse8_v_i8mf8 (out + i + j + 400, v1, vl);
+      }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-55.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-55.c
new file mode 100644
index 0000000..6c7aeea
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-55.c
@@ -0,0 +1,38 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f(void *base, void *out, void *mask_in, size_t m, size_t n) {
+  
+  size_t vl = 444;
+  for (size_t i = 0; i < m; i++) {
+    if (i % 2 == 0) {
+      for (size_t j = 0; j < n; j++){
+        if (j % 2 == 0) {
+          vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 200 + j, vl);
+          __riscv_vse8_v_i8mf8 (out + i + 200, v0, vl);
+        } else {
+          vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 300 + j, vl);
+          __riscv_vse8_v_i8mf8 (out + i + 300, v0, vl);
+        }
+      }
+    } else {
+      for (size_t j = 0; j < vl; j++){
+        if (j % 2 == 0) {
+          for (size_t k = 0; k < n; k++) {
+            vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 500 + k + j, vl);
+            vint8mf8_t v1 = __riscv_vle8_v_i8mf8_tu(v0, base + i + 600 + k + j, vl);
+            __riscv_vse8_v_i8mf8 (out + i + 600, v1, vl);
+          }
+        } else {
+          vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 700, vl);
+          __riscv_vse8_v_i8mf8 (out + i + 800, v0, vl);
+        }
+      }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-56.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-56.c
new file mode 100644
index 0000000..5d0584e
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-56.c
@@ -0,0 +1,38 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f(void *base, void *out, void *mask_in, size_t m, size_t n) {
+  
+  size_t vl = 555;
+  for (size_t i = 0; i < m; i++) {
+    if (i % 2 == 0) {
+      for (size_t j = 0; j < n; j++){
+        if (j % 2 == 0) {
+          vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 200 + j, vl);
+          __riscv_vse8_v_i8mf8 (out + i + 200, v0, vl);
+        } else {
+          vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 300 + j, vl);
+          vint8mf8_t v1 = __riscv_vle8_v_i8mf8_tu(v0, base + i + 300 + j, vl);
+          __riscv_vse8_v_i8mf8 (out + i + 300, v1, vl);
+        }
+      }
+    } else {
+      for (size_t j = 0; j < vl; j++){
+        if (j % 2 == 0) {
+          for (size_t k = 0; k < n; k++) {
+            vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 500 + k + j, vl);
+            __riscv_vse8_v_i8mf8 (out + i + 600, v0, vl);
+          }
+        } else {
+          vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 700, vl);
+          __riscv_vse8_v_i8mf8 (out + i + 800, v0, vl);
+        }
+      }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-57.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-57.c
new file mode 100644
index 0000000..a41065b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-57.c
@@ -0,0 +1,43 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f(void *base, void *out, void *mask_in, 
+size_t m, size_t n, size_t a, size_t b) {
+  
+  size_t vl = 666;
+  for (size_t i = 0; i < m; i++) {
+    if (i % 2 == 0) {
+      for (size_t j = 0; j < n; j++){
+        if (j % 2 == 0) {
+          vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 200 + j, vl);
+          __riscv_vse8_v_i8mf8 (out + i + 200, v0, vl);
+        } else {
+          vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 300 + j, vl);
+          __riscv_vse8_v_i8mf8 (out + i + 300, v0, vl);
+        }
+      }
+    } else {
+      for (size_t j = 0; j < vl; j++){
+        if (j % 2 == 0) {
+          for (size_t k = 0; k < n; k++) {
+            for (size_t i_a = 0; i_a < a; i_a++){
+              for (size_t i_b = 0; i_b < b; i_b++){
+                vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 500 + k + j + i_a + i_b, vl);
+                vint8mf8_t v1 = __riscv_vle8_v_i8mf8_tu(v0, base + i + 600 + k + j + i_a + i_b, vl);
+                __riscv_vse8_v_i8mf8 (out + i + 600 + j + k + i_a + i_b, v1, vl);
+              }
+            }
+          }
+        } else {
+          vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 700, vl);
+          __riscv_vse8_v_i8mf8 (out + i + 800, v0, vl);
+        }
+      }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-58.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-58.c
new file mode 100644
index 0000000..610b731
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-58.c
@@ -0,0 +1,43 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f(void *base, void *out, void *mask_in, 
+size_t m, size_t n, size_t a, size_t b) {
+  
+  size_t vl = 345;
+  for (size_t i = 0; i < m; i++) {
+    if (i % 2 == 0) {
+      for (size_t j = 0; j < n; j++){
+        if (j % 2 == 0) {
+          for (size_t k = 0; k < n; k++) {
+            for (size_t i_a = 0; i_a < a; i_a++){
+              for (size_t i_b = 0; i_b < b; i_b++){
+                vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 500 + k + j + i_a + i_b, vl);
+                vint8mf8_t v1 = __riscv_vle8_v_i8mf8_tu(v0, base + i + 600 + k + j + i_a + i_b, vl);
+                __riscv_vse8_v_i8mf8 (out + i + 600 + j + k + i_a + i_b, v1, vl);
+              }
+            }
+          }
+        } else {
+          vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 300 + j, vl);
+          __riscv_vse8_v_i8mf8 (out + i + 300, v0, vl);
+        }
+      }
+    } else {
+      for (size_t j = 0; j < vl; j++){
+        if (j % 2 == 0) {
+          vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 200 + j, vl);
+          __riscv_vse8_v_i8mf8 (out + i + 200, v0, vl);
+        } else {
+          vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 700, vl);
+          __riscv_vse8_v_i8mf8 (out + i + 800, v0, vl);
+        }
+      }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-59.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-59.c
new file mode 100644
index 0000000..82b82ae
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-59.c
@@ -0,0 +1,31 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f(void *base, void *out, void *mask_in, 
+size_t m, size_t n, size_t a, size_t b) {
+
+  size_t vl = 99;
+  for (size_t i = 0; i < m; i++) {
+    if (i % 2 == 0) {
+      for (size_t j = 0; j < n; j++){
+        if (j % 2 == 0) {
+          for (size_t k = 0; k < n; k++) {
+            for (size_t i_a = 0; i_a < a; i_a++){
+              for (size_t i_b = 0; i_b < b; i_b++){
+                vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 500 + k + j + i_a + i_b, vl);
+                vint8mf8_t v1 = __riscv_vle8_v_i8mf8_tu(v0, base + i + 600 + k + j + i_a + i_b, vl);
+                __riscv_vse8_v_i8mf8 (out + i + 600 + j + k + i_a + i_b, v1, vl);
+              }
+            }
+          }
+        } else {
+        }
+      }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-6.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-6.c
new file mode 100644
index 0000000..db2f750
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-6.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int l, int n, int m, size_t vl)
+{
+  for (int i = 0; i < l; i++){
+    vl++;
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j + k, vl);
+          __riscv_vse8_v_i8mf8 (out + i + j + k, v, vl);
+        }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {add\s+\s*[a-x0-9]+,\s*[a-x0-9]+,\s*[a-x0-9]+\s+vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {add\s+\s*[a-x0-9]+,\s*[a-x0-9]+,\s*[a-x0-9]+\s+li\s+[a-x0-9]+,0\s+vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-O1" no-opts "-O2" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-60.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-60.c
new file mode 100644
index 0000000..731184d
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-60.c
@@ -0,0 +1,30 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f(void *base, void *out, void *mask_in, 
+size_t m, size_t n, size_t a, size_t b) {
+  
+  size_t vl = 999;
+  for (size_t i = 0; i < m; i++) {
+    if (i % 2 == 0) {
+      for (size_t j = 0; j < n; j++){
+        if (j % 2 == 0) {
+          for (size_t k = 0; k < n; k++) {
+            for (size_t i_a = 0; i_a < a; i_a++){
+              for (size_t i_b = 0; i_b < b; i_b++){
+                vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 500 + k + j + i_a + i_b, vl);
+                vint8mf8_t v1 = __riscv_vle8_v_i8mf8_tu(v0, base + i + 600 + k + j + i_a + i_b, vl);
+                __riscv_vse8_v_i8mf8 (out + i + 600 + j + k + i_a + i_b, v1, vl);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-61.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-61.c
new file mode 100644
index 0000000..5e7dabf
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-61.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, size_t n, size_t cond)
+{
+  for (size_t i = 0; i < n; i++)
+    {
+      if (i != cond) {
+        size_t vl = 55;
+        vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + 100, vl);
+        __riscv_vse8_v_i8mf8 (out + i + 100, v, vl);
+      } else {
+      size_t vl = 66;
+        vint32m1_t v = __riscv_vle32_v_i32m1 (in + i + 200, vl);
+        __riscv_vse32_v_i32m1 (out + i + 200, v, vl);
+      }
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 3 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-62.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-62.c
new file mode 100644
index 0000000..fbc4d58
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-62.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, size_t n, size_t cond)
+{
+  for (size_t i = 0; i < n; i++)
+    {
+      if (i == cond) {
+        size_t vl = 55;
+        vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + 100, vl);
+        __riscv_vse8_v_i8mf8 (out + i + 100, v, vl);
+      } else {
+      size_t vl = 66;
+        vint32m1_t v = __riscv_vle32_v_i32m1 (in + i + 200, vl);
+        __riscv_vse32_v_i32m1 (out + i + 200, v, vl);
+      }
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 3 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-63.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-63.c
new file mode 100644
index 0000000..5433b18
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-63.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int n, int cond)
+{
+  size_t vl = 111;
+  if (n > cond) {
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + 600, vl);
+    vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + 600, vl);
+    __riscv_vse8_v_i8mf8 (out + 600, v2, vl);
+  } else {
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + 700, vl);
+    __riscv_vse8_v_i8mf8 (out + 700, v, vl);
+  }
+
+  for (int i = 0 ; i < n * n * n * n; i++) {
+    vint8mf8_t v = *(vint8mf8_t*) (in + 900 + i);
+    *(vint8mf8_t*) (out + 900 + i) = v;
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli} 3 { target { no-opts "-O0"  no-opts "-funroll-loops" no-opts "-g" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-64.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-64.c
new file mode 100644
index 0000000..093f67f
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-64.c
@@ -0,0 +1,41 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int n, int cond)
+{
+  size_t vl = 777;
+  if (n > cond) {
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + 600, vl);
+    vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + 600, vl);
+    __riscv_vse8_v_i8mf8 (out + 600, v2, vl);
+  } else {
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + 700, vl);
+    __riscv_vse8_v_i8mf8 (out + 700, v, vl);
+  }
+
+  for (int i = 0 ; i < n * n * n * n; i++) {
+    vint8mf8_t v = *(vint8mf8_t*) (in + 900 + i);
+    *(vint8mf8_t*) (out + 900 + i) = v;
+  }
+
+  for (int i = 0 ; i < n; i++) {
+    vint32m1_t v = __riscv_vle32_v_i32m1 (in + 1000 + i, vl);
+    __riscv_vse32_v_i32m1 (out + 1000 + i, v, vl);
+  }
+  
+  vl = 888;
+  for (int i = 0 ; i < n; i++) {
+    vint32m1_t v = __riscv_vle32_v_i32m1 (in + 1000 + i, vl);
+    __riscv_vse32_v_i32m1 (out + 1000 + i, v, vl);
+  }
+  
+  vl = 444;
+  for (int i = 0 ; i < n * n; i++) {
+    vint32m1_t v = __riscv_vle32_v_i32m1 (in + 2000 + i, vl);
+    __riscv_vse32_v_i32m1 (out + 2000 + i, v, vl);
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli} 6 { target { no-opts "-O0"  no-opts "-funroll-loops" no-opts "-g" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-65.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-65.c
new file mode 100644
index 0000000..c440b9b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-65.c
@@ -0,0 +1,33 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int n, int n2)
+{
+  size_t vl;
+  asm volatile ("li %0, 101" :"=r" (vl)::"memory");
+
+  for (int i = 0 ; i < n * n * n * n; i++) {
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + 900 + i, vl);
+    __riscv_vse8_v_i8mf8 (out + 900 + i, v, vl);
+  }
+  
+  for (int i = 0 ; i < n * n; i++)
+    out[i] = out[i] + out[i];
+  
+  for (int i = 0 ; i < n * n * n; i++)
+    out[i] = out[i] * out[i];
+
+  for (int i = 0 ; i < n * n * n * n; i++)
+    out[i] = out[i] * out[i];
+  
+  for (int i = 0 ; i < n2; i++) {
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + 800 + i, vl);
+    v = __riscv_vle8_v_i8mf8_tu (v, in + 900 + i, vl);
+    __riscv_vse8_v_i8mf8 (out + 800 + i, v, vl);
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]} 3 { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 3 { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-66.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-66.c
new file mode 100644
index 0000000..dfbb744
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-66.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f2 (void * restrict in, void * restrict out, int l, int n, int m, size_t vl)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j + k, vl);
+          __riscv_vse8_v_i8mf8 (out + i + j + k, v, vl);
+        }
+    }
+    vl++;
+  }
+}
+
+/* { dg-final { scan-assembler-times {add\s+\s*[a-x0-9]+,\s*[a-x0-9]+,\s*[a-x0-9]+\s+vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-67.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-67.c
new file mode 100644
index 0000000..b9f49b90
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-67.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f2 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  size_t vl = 101;
+  for (int i = 0; i < l; i++){
+    size_t vl = i + vl + 44;
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j + k + 10000, vl);
+          v = __riscv_vle8_v_i8mf8_tu (v, in + i + j + k + 20000, j);
+          __riscv_vse8_v_i8mf8 (out + i + j + k + 20000, v, vl);
+        }
+    }
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i, vl);
+    __riscv_vse8_v_i8mf8 (out + i, v, vl);
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 3 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {addi\s+[a-x0-9]+,\s*[a-x0-9]+,\s*44} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-68.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-68.c
new file mode 100644
index 0000000..da6e5a8
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-68.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f2 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  size_t vl = 101;
+  for (int i = 0; i < l; i++){
+    size_t vl = i + vl + 44;
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j + k + 10000, vl);
+          v = __riscv_vle8_v_i8mf8_tu (v, in + i + j + k + 20000, vl);
+          __riscv_vse8_v_i8mf8 (out + i + j + k + 20000, v, vl);
+        }
+    }
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i, vl);
+    __riscv_vse8_v_i8mf8 (out + i, v, vl);
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {addi\s+[a-x0-9]+,\s*[a-x0-9]+,\s*44} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-69.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-69.c
new file mode 100644
index 0000000..81699d7
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-69.c
@@ -0,0 +1,40 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int l, int n, int m, size_t cond)
+{
+  size_t vl = 555;
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j + k, vl);
+          __riscv_vse8_v_i8mf8 (out + i + j + k, v, vl);
+        }
+    }
+  }
+  
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          out[i+j+k+10000000] = out[i+j+k+10000000] + in[i+j+k+10000000];
+        }
+    }
+  }
+
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j + k + 10000, vl);
+          __riscv_vse8_v_i8mf8 (out + i + j + k + 10000, v, vl);
+        }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-7.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-7.c
new file mode 100644
index 0000000..bd407b2
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-7.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int n)
+{
+  register size_t vl asm ("a5");
+  for (int i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i, vl);
+      __riscv_vse8_v_i8mf8 (out + i, v, vl);
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*a5,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-70.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-70.c
new file mode 100644
index 0000000..d9c35cb
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-70.c
@@ -0,0 +1,46 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int l, int n, int m, size_t cond)
+{
+  size_t vl = 555;
+  
+  if (cond) {
+    for (int i = 0; i < l; i++){
+      for (int j = 0; j < m; j++){
+        for (int k = 0; k < n; k++)
+          {
+            vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j + k, vl);
+            __riscv_vse8_v_i8mf8 (out + i + j + k, v, vl);
+          }
+      }
+    }
+  } else {
+    out[999] = out[999] * in[999];
+  }
+  
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          out[i+j+k+10000000] = out[i+j+k+10000000] + in[i+j+k+10000000];
+        }
+    }
+  }
+
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j + k + 10000, vl);
+          v = __riscv_vle8_v_i8mf8_tu (v, in + i + j + k + 20000, vl);
+          __riscv_vse8_v_i8mf8 (out + i + j + k + 10000, v, vl);
+        }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]} 2 { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-71.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-71.c
new file mode 100644
index 0000000..06706d6
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-71.c
@@ -0,0 +1,54 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int l, int n, int m, size_t cond)
+{
+  size_t vl = 555;
+  
+  if (cond) {
+    for (int i = 0; i < l; i++){
+      for (int j = 0; j < m; j++){
+        for (int k = 0; k < n; k++)
+          {
+            vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j + k, vl);
+            __riscv_vse8_v_i8mf8 (out + i + j + k, v, vl);
+          }
+      }
+    }
+  } else {
+    for (int i = 0; i < l; i++){
+      for (int j = 0; j < m; j++){
+        for (int k = 0; k < n; k++)
+          {
+            vint32mf2_t v = __riscv_vle32_v_i32mf2 ((int32_t *)(in + i + j + k), vl);
+            __riscv_vse32_v_i32mf2 ((int32_t *)(out + i + j + k), v, vl);
+          }
+      }
+    }
+  }
+  
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          out[i+j+k+10000000] = out[i+j+k+10000000] + in[i+j+k+10000000];
+        }
+    }
+  }
+
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j + k + 10000, vl);
+          v = __riscv_vle8_v_i8mf8_tu (v, in + i + j + k + 20000, vl);
+          __riscv_vse8_v_i8mf8 (out + i + j + k + 10000, v, vl);
+        }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*tu,\s*m[au]} 3 { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 3 { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-72.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-72.c
new file mode 100644
index 0000000..b1e28ab
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-72.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int n, int cond)
+{
+  size_t vl = 101;
+  for (size_t i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i, vl);
+      __riscv_vse8_v_i8mf8 (out + i, v, vl);
+      
+      vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + i + 100, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 100, v2, vl);
+    }
+  
+  for (size_t i = 0; i < n; i++)
+    {
+      vuint8mf8_t index = __riscv_vle8_v_u8mf8 (in + i + 300, vl);
+      vfloat32mf2_t v2 = __riscv_vluxei8_v_f32mf2 (in + i + 200, index, vl);
+      __riscv_vse32_v_f32mf2 (out + i + 200, v2, vl);
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-73.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-73.c
new file mode 100644
index 0000000..cd9bb80
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-73.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int n, int cond, size_t vl, size_t vl2)
+{
+  for (size_t i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + 300, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 300, v, vl);
+    }
+  
+  for (size_t i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i, vl2);
+      __riscv_vse8_v_i8mf8 (out + i, v, vl2);
+      
+      vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + i + 100, vl2);
+      __riscv_vse8_v_i8mf8 (out + i + 100, v2, vl2);
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-74.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-74.c
new file mode 100644
index 0000000..568615a
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-74.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int n, int cond, size_t vl, size_t vl2)
+{
+  if (cond)
+    vl = 101;
+  for (size_t i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + 300, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 300, v, vl);
+    }
+  
+  for (size_t i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i, vl);
+      __riscv_vse8_v_i8mf8 (out + i, v, vl);
+      
+      vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + i + 100, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 100, v2, vl);
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-75.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-75.c
new file mode 100644
index 0000000..b7680ec
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-75.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int n, int cond, size_t vl, size_t vl2)
+{
+  if (cond)
+    vl = 101;
+  for (size_t i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + 300, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 300, v, vl);
+    }
+  
+  vl = 101;
+  for (size_t i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i, vl);
+      __riscv_vse8_v_i8mf8 (out + i, v, vl);
+      
+      vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + i + 100, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 100, v2, vl);
+    }
+}
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-76.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-76.c
new file mode 100644
index 0000000..1b6e818
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-76.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int n, int cond)
+{
+  size_t vl = 101;
+  for (size_t i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i, vl);
+      __riscv_vse8_v_i8mf8 (out + i, v, vl);
+    }
+  
+  for (size_t i = 0; i < n; i++)
+    {
+      vuint8mf8_t index = __riscv_vle8_v_u8mf8 (in + i + 300, vl);
+      vfloat32mf2_t v = __riscv_vle32_v_f32mf2 (in + i + 600, vl);
+      __riscv_vsoxei8_v_f32mf2 (out + i + 200, index, v, vl);
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-77.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-77.c
new file mode 100644
index 0000000..9fb1605
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-77.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int n, int cond)
+{
+  size_t vl = 101;
+  for (size_t i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i, vl);
+      __riscv_vse8_v_i8mf8 (out + i, v, vl);
+    }
+  
+  for (size_t i = 0; i < n; i++)
+    {
+      vbool64_t mask = __riscv_vlm_v_b64 (in + 10000, vl);
+      vuint8mf8_t index = __riscv_vle8_v_u8mf8 (in + i + 300, vl);
+      vfloat32mf2_t v = __riscv_vle32_v_f32mf2 (in + i + 30000, vl);
+      vfloat32mf2_t v2 = __riscv_vluxei8_v_f32mf2_tumu (mask, v, in + i + 200, index, vl);
+      __riscv_vse32_v_f32mf2 (out + i + 200, v2, vl);
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*mf2,\s*tu,\s*mu} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-8.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-8.c
new file mode 100644
index 0000000..0785af7
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-8.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int n)
+{
+  size_t vl = 32;
+  for (int i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i, vl);
+      __riscv_vse8_v_i8mf8 (out + i, v, vl);
+    }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle8\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-9.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-9.c
new file mode 100644
index 0000000..8f47258
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/avl_single-9.c
@@ -0,0 +1,57 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  int vl = 32;
+  for (int i = 0; i < n; i++)
+    {
+      vint8mf8_t v1 = __riscv_vle8_v_i8mf8 (in + i + 1, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 1, v1, vl);
+
+      vint8mf8_t v2 = __riscv_vle8_v_i8mf8 (in + i + 2, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 2, v2, vl);
+
+      vint8mf8_t v3 = __riscv_vle8_v_i8mf8 (in + i + 3, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 3, v3, vl);
+
+      vint8mf8_t v4 = __riscv_vle8_v_i8mf8 (in + i + 4, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 4, v4, vl);
+
+      vint8mf8_t v5 = __riscv_vle8_v_i8mf8 (in + i + 5, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 5, v5, vl);
+
+      vint8mf8_t v6 = __riscv_vle8_v_i8mf8 (in + i + 6, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 6, v6, vl);
+
+      vint8mf8_t v7 = __riscv_vle8_v_i8mf8 (in + i + 7, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 7, v7, vl);
+
+      vint8mf8_t v8 = __riscv_vle8_v_i8mf8 (in + i + 8, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 8, v8, vl);
+
+      vint8mf8_t v9 = __riscv_vle8_v_i8mf8 (in + i + 9, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 9, v9, vl);
+
+      vint8mf8_t v10 = __riscv_vle8_v_i8mf8 (in + i + 10, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 10, v10, vl);
+
+      vint8mf8_t v11 = __riscv_vle8_v_i8mf8 (in + i + 11, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 11, v11, vl);
+
+      vint8mf8_t v12 = __riscv_vle8_v_i8mf8 (in + i + 12, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 12, v12, vl);
+
+      vint8mf8_t v13 = __riscv_vle8_v_i8mf8 (in + i + 13, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 13, v13, vl);
+
+      vint8mf8_t v14 = __riscv_vle8_v_i8mf8 (in + i + 14, vl);
+      __riscv_vse8_v_i8mf8 (out + i + 14, v14, vl);
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {li\s+[a-x0-9]+,32} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-1.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-1.c
new file mode 100644
index 0000000..cd4ee7d
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-1.c
@@ -0,0 +1,32 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int n, int cond)
+{
+  if (n > cond) {
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + 600, 5);
+    vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + 600, 5);
+    __riscv_vse8_v_i8mf8 (out + 600, v2, 5);
+  } else {
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + 700, 5);
+    __riscv_vse8_v_i8mf8 (out + 700, v, 5);
+  }
+
+  for (int i = 0 ; i < n * n; i++)
+    out[i] = out[i] + out[i];
+  
+  for (int i = 0 ; i < n * n * n; i++)
+    out[i] = out[i] * out[i];
+
+  for (int i = 0 ; i < n * n * n * n; i++)
+    out[i] = out[i] * out[i];
+  
+  for (int i = 0 ; i < n * n * n * n; i++) {
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + 900 + i, 5);
+    __riscv_vse8_v_i8mf8 (out + 900 + i, v, 5);
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*5,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-10.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-10.c
new file mode 100644
index 0000000..cdb2c8f
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-10.c
@@ -0,0 +1,42 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f(void *base, void *out, void *mask_in, 
+size_t vl, size_t m, size_t n, size_t a, size_t b) {
+
+  for (size_t i = 0; i < m; i++) {
+    if (i % 2 == 0) {
+      for (size_t j = 0; j < n; j++){
+        if (j % 2 == 0) {
+          vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 200 + j, 4);
+          __riscv_vse8_v_i8mf8 (out + i + 200, v0, 4);
+        } else {
+          vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 300 + j, 4);
+          __riscv_vse8_v_i8mf8 (out + i + 300, v0, 4);
+        }
+      }
+    } else {
+      for (size_t j = 0; j < vl; j++){
+        if (j % 2 == 0) {
+          for (size_t k = 0; k < n; k++) {
+            for (size_t i_a = 0; i_a < a; i_a++){
+              for (size_t i_b = 0; i_b < b; i_b++){
+                vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 500 + k + j + i_a + i_b, 4);
+                vint8mf8_t v1 = __riscv_vle8_v_i8mf8_tu(v0, base + i + 600 + k + j + i_a + i_b, 4);
+                __riscv_vse8_v_i8mf8 (out + i + 600 + j + k + i_a + i_b, v1, 4);
+              }
+            }
+          }
+        } else {
+          vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 700, 4);
+          __riscv_vse8_v_i8mf8 (out + i + 800, v0, 4);
+        }
+      }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*4,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-11.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-11.c
new file mode 100644
index 0000000..ba2d57e
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-11.c
@@ -0,0 +1,42 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f(void *base, void *out, void *mask_in, 
+size_t vl, size_t m, size_t n, size_t a, size_t b) {
+
+  for (size_t i = 0; i < m; i++) {
+    if (i % 2 == 0) {
+      for (size_t j = 0; j < n; j++){
+        if (j % 2 == 0) {
+          for (size_t k = 0; k < n; k++) {
+            for (size_t i_a = 0; i_a < a; i_a++){
+              for (size_t i_b = 0; i_b < b; i_b++){
+                vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 500 + k + j + i_a + i_b, 4);
+                vint8mf8_t v1 = __riscv_vle8_v_i8mf8_tu(v0, base + i + 600 + k + j + i_a + i_b, 4);
+                __riscv_vse8_v_i8mf8 (out + i + 600 + j + k + i_a + i_b, v1, 4);
+              }
+            }
+          }
+        } else {
+          vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 300 + j, 4);
+          __riscv_vse8_v_i8mf8 (out + i + 300, v0, 4);
+        }
+      }
+    } else {
+      for (size_t j = 0; j < vl; j++){
+        if (j % 2 == 0) {
+          vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 200 + j, 4);
+          __riscv_vse8_v_i8mf8 (out + i + 200, v0, 4);
+        } else {
+          vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 700, 4);
+          __riscv_vse8_v_i8mf8 (out + i + 800, v0, 4);
+        }
+      }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*4,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-12.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-12.c
new file mode 100644
index 0000000..ced6cb8
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-12.c
@@ -0,0 +1,31 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f(void *base, void *out, void *mask_in, 
+size_t vl, size_t m, size_t n, size_t a, size_t b) {
+
+  for (size_t i = 0; i < m; i++) {
+    if (i % 2 == 0) {
+      for (size_t j = 0; j < n; j++){
+        if (j % 2 == 0) {
+          for (size_t k = 0; k < n; k++) {
+            for (size_t i_a = 0; i_a < a; i_a++){
+              for (size_t i_b = 0; i_b < b; i_b++){
+                vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 500 + k + j + i_a + i_b, 4);
+                vint8mf8_t v1 = __riscv_vle8_v_i8mf8_tu(v0, base + i + 600 + k + j + i_a + i_b, 4);
+                __riscv_vse8_v_i8mf8 (out + i + 600 + j + k + i_a + i_b, v1, 4);
+              }
+            }
+          }
+        } else {
+        }
+      }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*4,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-13.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-13.c
new file mode 100644
index 0000000..fd75172
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-13.c
@@ -0,0 +1,29 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f(void *base, void *out, void *mask_in, 
+size_t vl, size_t m, size_t n, size_t a, size_t b) {
+
+  for (size_t i = 0; i < m; i++) {
+    if (i % 2 == 0) {
+      for (size_t j = 0; j < n; j++){
+        if (j % 2 == 0) {
+          for (size_t k = 0; k < n; k++) {
+            for (size_t i_a = 0; i_a < a; i_a++){
+              for (size_t i_b = 0; i_b < b; i_b++){
+                vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 500 + k + j + i_a + i_b, 4);
+                vint8mf8_t v1 = __riscv_vle8_v_i8mf8_tu(v0, base + i + 600 + k + j + i_a + i_b, 4);
+                __riscv_vse8_v_i8mf8 (out + i + 600 + j + k + i_a + i_b, v1, 4);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*4,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-2.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-2.c
new file mode 100644
index 0000000..61bf57b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-2.c
@@ -0,0 +1,29 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int n, int n2)
+{
+  for (int i = 0 ; i < n2; i++) {
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + 800 + i, 9);
+    __riscv_vse8_v_i8mf8 (out + 800 + i, v, 9);
+  }
+
+  for (int i = 0 ; i < n * n; i++)
+    out[i] = out[i] + out[i];
+  
+  for (int i = 0 ; i < n * n * n; i++)
+    out[i] = out[i] * out[i];
+
+  for (int i = 0 ; i < n * n * n * n; i++)
+    out[i] = out[i] * out[i];
+  
+  for (int i = 0 ; i < n * n * n * n; i++) {
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + 900 + i, 5);
+    __riscv_vse8_v_i8mf8 (out + 900 + i, v, 5);
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*9,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*5,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-O1" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-3.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-3.c
new file mode 100644
index 0000000..3da7b87
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-3.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f(void *base, void *out, void *mask_in, size_t vl, size_t m) {
+  vbool64_t mask = *(vbool64_t*)mask_in;
+
+  for (size_t i = 0; i < m; i++) {
+    if (i % 2 == 0) {
+      vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i, 4);
+      vint8mf8_t v1 = __riscv_vle8_v_i8mf8_tu(v0, base + i + 100, 4);
+      __riscv_vse8_v_i8mf8 (out + i, v1, 4);
+    } else {
+      vint16mf4_t v0 = __riscv_vle16_v_i16mf4(base + i, 4);
+      vint16mf4_t v1 = __riscv_vle16_v_i16mf4_mu(mask, v0, base + i + 100, 4);
+      __riscv_vse16_v_i16mf4 (out + i, v1, 4);
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*4,\s*e8,\s*mf8,\s*tu,\s*mu} 1 { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-4.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-4.c
new file mode 100644
index 0000000..2a9616e
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-4.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f(void *base, void *out, void *mask_in, size_t vl, size_t m, size_t n) {
+  vbool64_t mask = *(vbool64_t*)mask_in;
+
+  for (size_t i = 0; i < m; i++) {
+    for (size_t j = 0; j < n; j++){
+      if ((i + j) % 2 == 0) {
+        vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + j, 4);
+        vint8mf8_t v1 = __riscv_vle8_v_i8mf8_tu(v0, base + i + j + 100, 4);
+        __riscv_vse8_v_i8mf8 (out + i + j, v1, 4);
+      } else {
+        vint16mf4_t v0 = __riscv_vle16_v_i16mf4(base + i + j, 4);
+        vint16mf4_t v1 = __riscv_vle16_v_i16mf4_mu(mask, v0, base + i + j + 100, 4);
+        __riscv_vse16_v_i16mf4 (out + i + j, v1, 4);
+      }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*4,\s*e8,\s*mf8,\s*tu,\s*mu} 1 { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-5.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-5.c
new file mode 100644
index 0000000..21be9c0
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-5.c
@@ -0,0 +1,33 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f(void *base, void *out, void *mask_in, size_t vl, size_t m, size_t n) {
+
+  for (size_t i = 0; i < m; i++) {
+    if (i % 2 == 0) {
+      for (size_t j = 0; j < n; j++){
+        vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + j + 700, 4);
+        vint8mf8_t v1 = __riscv_vle8_v_i8mf8_tu(v0, base + i + j + 700, 4);
+        __riscv_vse8_v_i8mf8 (out + i + j + 700, v1, 4);
+        if (j % 2 == 0) {
+          vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + j + 500, 4);
+          __riscv_vse8_v_i8mf8 (out + i + j + 500, v0, 4);
+        } else {
+          vint16mf4_t v0 = __riscv_vle16_v_i16mf4(base + i + j + 600, 4);
+          __riscv_vse16_v_i16mf4 (out + i + j + 600, v0, 4);
+        }
+      }
+    } else {
+      for (size_t j = 0; j < n; j++){
+        vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + j + 200, 4);
+        vint8mf8_t v1 = __riscv_vle8_v_i8mf8_tu(v0, base + i + j + 300, 4);
+        __riscv_vse8_v_i8mf8 (out + i + j + 400, v1, 4);
+      }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*4,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-6.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-6.c
new file mode 100644
index 0000000..92d830c
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-6.c
@@ -0,0 +1,30 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f(void *base, void *out, void *mask_in, size_t vl, size_t m, size_t n) {
+
+  for (size_t i = 0; i < m; i++) {
+    if (i % 2 == 0) {
+      for (size_t j = 0; j < n; j++){
+        if (j % 2 == 0) {
+          vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + j + 500, 4);
+          __riscv_vse8_v_i8mf8 (out + i + j + 500, v0, 4);
+        } else {
+          vint16mf4_t v0 = __riscv_vle16_v_i16mf4(base + i + j + 600, 4);
+          __riscv_vse16_v_i16mf4 (out + i + j + 600, v0, 4);
+        }
+      }
+    } else {
+      for (size_t j = 0; j < n; j++){
+        vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + j + 200, 4);
+        vint8mf8_t v1 = __riscv_vle8_v_i8mf8_tu(v0, base + i + j + 300, 4);
+        __riscv_vse8_v_i8mf8 (out + i + j + 400, v1, 4);
+      }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*4,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-7.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-7.c
new file mode 100644
index 0000000..550c3a3
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-7.c
@@ -0,0 +1,31 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f(void *base, void *out, void *mask_in, size_t vl, size_t m, size_t n) {
+
+  for (size_t i = 0; i < m; i++) {
+    if (i % 2 == 0) {
+      for (size_t j = 0; j < n; j++){
+        if (j % 2 == 0) {
+          vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 200, 4);
+          vint8mf8_t v1 = __riscv_vle8_v_i8mf8_tu(v0, base + i + 200, 4);
+          __riscv_vse8_v_i8mf8 (out + i + 200, v1, 4);
+        } else {
+          vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 300, 4);
+          vint8mf8_t v1 = __riscv_vle8_v_i8mf8_tu(v0, base + i + 300, 4);
+          __riscv_vse8_v_i8mf8 (out + i + 300, v1, 4);
+        }
+      }
+    } else {
+      for (size_t j = 0; j < n; j++){
+        vint8mf8_t v1 = __riscv_vle8_v_i8mf8(base + i + j + 300, 4);
+        __riscv_vse8_v_i8mf8 (out + i + j + 400, v1, 4);
+      }
+    }
+  }
+}
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*4,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-8.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-8.c
new file mode 100644
index 0000000..667effa
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-8.c
@@ -0,0 +1,37 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f(void *base, void *out, void *mask_in, size_t vl, size_t m, size_t n) {
+
+  for (size_t i = 0; i < m; i++) {
+    if (i % 2 == 0) {
+      for (size_t j = 0; j < n; j++){
+        if (j % 2 == 0) {
+          vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 200 + j, 4);
+          __riscv_vse8_v_i8mf8 (out + i + 200, v0, 4);
+        } else {
+          vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 300 + j, 4);
+          __riscv_vse8_v_i8mf8 (out + i + 300, v0, 4);
+        }
+      }
+    } else {
+      for (size_t j = 0; j < vl; j++){
+        if (j % 2 == 0) {
+          for (size_t k = 0; k < n; k++) {
+            vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 500 + k + j, 4);
+            vint8mf8_t v1 = __riscv_vle8_v_i8mf8_tu(v0, base + i + 600 + k + j, 4);
+            __riscv_vse8_v_i8mf8 (out + i + 600, v1, 4);
+          }
+        } else {
+          vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 700, 4);
+          __riscv_vse8_v_i8mf8 (out + i + 800, v0, 4);
+        }
+      }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*4,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-9.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-9.c
new file mode 100644
index 0000000..3b486df
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_bb_prop-9.c
@@ -0,0 +1,37 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f(void *base, void *out, void *mask_in, size_t vl, size_t m, size_t n) {
+
+  for (size_t i = 0; i < m; i++) {
+    if (i % 2 == 0) {
+      for (size_t j = 0; j < n; j++){
+        if (j % 2 == 0) {
+          vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 200 + j, 4);
+          __riscv_vse8_v_i8mf8 (out + i + 200, v0, 4);
+        } else {
+          vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 300 + j, 4);
+          vint8mf8_t v1 = __riscv_vle8_v_i8mf8_tu(v0, base + i + 300 + j, 4);
+          __riscv_vse8_v_i8mf8 (out + i + 300, v1, 4);
+        }
+      }
+    } else {
+      for (size_t j = 0; j < vl; j++){
+        if (j % 2 == 0) {
+          for (size_t k = 0; k < n; k++) {
+            vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 500 + k + j, 4);
+            __riscv_vse8_v_i8mf8 (out + i + 600, v0, 4);
+          }
+        } else {
+          vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i + 700, 4);
+          __riscv_vse8_v_i8mf8 (out + i + 800, v0, 4);
+        }
+      }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*4,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_conflict-1.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_conflict-1.c
new file mode 100644
index 0000000..331ebab
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_conflict-1.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, size_t n, size_t cond)
+{
+  for (size_t i = 0; i < n; i++)
+    {
+      if (i != cond) {
+        vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + 100, 17);
+        __riscv_vse8_v_i8mf8 (out + i + 100, v, 17);
+      } else {
+        vint32m1_t v = __riscv_vle32_v_i32m1 (in + i + 200, 4);
+        __riscv_vse32_v_i32m1 (out + i + 200, v, 4);
+      }
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*4,\s*e32,\s*m1,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli} 3 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_conflict-2.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_conflict-2.c
new file mode 100644
index 0000000..3ed73ea
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_conflict-2.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, size_t n, size_t cond)
+{
+  for (size_t i = 0; i < n; i++)
+    {
+      if (i == cond) {
+        vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + 100, 17);
+        __riscv_vse8_v_i8mf8 (out + i + 100, v, 17);
+      } else {
+        vint32m1_t v = __riscv_vle32_v_i32m1 (in + i + 200, 4);
+        __riscv_vse32_v_i32m1 (out + i + 200, v, 4);
+      }
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*4,\s*e32,\s*m1,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli} 3 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_conflict-3.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_conflict-3.c
new file mode 100644
index 0000000..1f7c0f0
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_conflict-3.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (int8_t * restrict in, int8_t * restrict out, int n, int cond)
+{
+  if (n > cond) {
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + 600, 5);
+    vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + 600, 5);
+    __riscv_vse8_v_i8mf8 (out + 600, v2, 5);
+  } else {
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + 700, 5);
+    __riscv_vse8_v_i8mf8 (out + 700, v, 5);
+  }
+
+  for (int i = 0 ; i < n * n * n * n; i++) {
+    vint8mf8_t v = *(vint8mf8_t*) (in + 900 + i);
+    *(vint8mf8_t*) (out + 900 + i) = v;
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*5,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0"  no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli} 1 { target { no-opts "-O0"  no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0"  no-opts "-funroll-loops" no-opts "-g" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_conflict-4.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_conflict-4.c
new file mode 100644
index 0000000..1671bb5
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_conflict-4.c
@@ -0,0 +1,36 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int n, int cond)
+{
+  if (n > cond) {
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + 600, 5);
+    vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + 600, 5);
+    __riscv_vse8_v_i8mf8 (out + 600, v2, 5);
+  } else {
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + 700, 5);
+    __riscv_vse8_v_i8mf8 (out + 700, v, 5);
+  }
+
+  for (int i = 0 ; i < n * n * n * n; i++) {
+    vint8mf8_t v = *(vint8mf8_t*) (in + 900 + i);
+    *(vint8mf8_t*) (out + 900 + i) = v;
+  }
+
+  for (int i = 0 ; i < n; i++) {
+    vint32m1_t v = __riscv_vle32_v_i32m1 (in + 1000 + i, 19);
+    __riscv_vse32_v_i32m1 (out + 1000 + i, v, 19);
+  }
+
+  for (int i = 0 ; i < n * n; i++) {
+    vint32m1_t v = __riscv_vle32_v_i32m1 (in + 2000 + i, 8);
+    __riscv_vse32_v_i32m1 (out + 2000 + i, v, 8);
+  }
+}
+
+/* { dg-final { scan-assembler {vsetivli\s+zero,\s*5,\s*e8,\s*mf8,\s*tu,\s*m[au]} { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler {vsetivli\s+zero,\s*19,\s*e32,\s*m1,\s*t[au],\s*m[au]} { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler {vsetivli\s+zero,\s*8,\s*e32,\s*m1,\s*t[au],\s*m[au]} { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]} { target { no-opts "-O0" no-opts "-O1" no-opts "-Os"  no-opts "-funroll-loops" no-opts "-g" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_conflict-5.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_conflict-5.c
new file mode 100644
index 0000000..c4e25f4
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_conflict-5.c
@@ -0,0 +1,43 @@
+#include "riscv_vector.h"
+
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int n, int cond)
+{
+  if (n > cond) {
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + 600, 5);
+    vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + 600, 5);
+    __riscv_vse8_v_i8mf8 (out + 600, v2, 5);
+  } else {
+    vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + 700, 5);
+    __riscv_vse8_v_i8mf8 (out + 700, v, 5);
+  }
+
+  for (int i = 0 ; i < n * n * n * n; i++) {
+    vint8mf8_t v = *(vint8mf8_t*) (in + 900 + i);
+    *(vint8mf8_t*) (out + 900 + i) = v;
+  }
+
+  for (int i = 0 ; i < n; i++) {
+    vint32m1_t v = __riscv_vle32_v_i32m1 (in + 1000 + i, 19);
+    __riscv_vse32_v_i32m1 (out + 1000 + i, v, 19);
+  }
+
+  for (int i = 0 ; i < n * n; i++) {
+    vint32m1_t v = __riscv_vle32_v_i32m1 (in + 2000 + i, 8);
+    __riscv_vse32_v_i32m1 (out + 2000 + i, v, 8);
+  }
+
+  for (int i = 0 ; i < n * n * n; i++) {
+    vint16mf2_t v = __riscv_vle16_v_i16mf2 (in + 3000 + i, 8);
+    __riscv_vse16_v_i16mf2 (out + 3000 + i, v, 8);
+  }
+}
+
+/* { dg-final { scan-assembler {vsetivli\s+zero,\s*5,\s*e8,\s*mf8,\s*tu,\s*m[au]} { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler {vsetivli\s+zero,\s*19,\s*e32,\s*m1,\s*t[au],\s*m[au]} { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler {vsetivli\s+zero,\s*8,\s*e32,\s*m1,\s*t[au],\s*m[au]} { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]} { target { no-opts "-O0" no-opts "-O1" no-opts "-Os"  no-opts "-funroll-loops" no-opts "-g" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-1.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-1.c
new file mode 100644
index 0000000..618adb7
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-1.c
@@ -0,0 +1,195 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f1 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j, 17);
+          __riscv_vse8_v_i8mf8 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f2 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vuint8mf8_t v = __riscv_vle8_v_u8mf8 (in + i + j, 17);
+          __riscv_vse8_v_u8mf8 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f3 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint8mf4_t v = __riscv_vle8_v_i8mf4 (in + i + j, 17);
+          __riscv_vse8_v_i8mf4 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f4 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vuint8mf4_t v = __riscv_vle8_v_u8mf4 (in + i + j, 17);
+          __riscv_vse8_v_u8mf4 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f5 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint8mf2_t v = __riscv_vle8_v_i8mf2 (in + i + j, 17);
+          __riscv_vse8_v_i8mf2 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f6 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vuint8mf2_t v = __riscv_vle8_v_u8mf2 (in + i + j, 17);
+          __riscv_vse8_v_u8mf2 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f7 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint8m1_t v = __riscv_vle8_v_i8m1 (in + i + j, 17);
+          __riscv_vse8_v_i8m1 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f8 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vuint8m1_t v = __riscv_vle8_v_u8m1 (in + i + j, 17);
+          __riscv_vse8_v_u8m1 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f9 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint8m2_t v = __riscv_vle8_v_i8m2 (in + i + j, 17);
+          __riscv_vse8_v_i8m2 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f10 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vuint8m2_t v = __riscv_vle8_v_u8m2 (in + i + j, 17);
+          __riscv_vse8_v_u8m2 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f11 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint8m4_t v = __riscv_vle8_v_i8m4 (in + i + j, 17);
+          __riscv_vse8_v_i8m4 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f12 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vuint8m4_t v = __riscv_vle8_v_u8m4 (in + i + j, 17);
+          __riscv_vse8_v_u8m4 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f13 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint8m8_t v = __riscv_vle8_v_i8m8 (in + i + j, 17);
+          __riscv_vse8_v_i8m8 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f14 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vuint8m8_t v = __riscv_vle8_v_u8m8 (in + i + j, 17);
+          __riscv_vse8_v_u8m8 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle8\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 14 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e8,\s*mf4,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e8,\s*mf2,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e8,\s*m1,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e8,\s*m2,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e8,\s*m4,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e8,\s*m8,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-10.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-10.c
new file mode 100644
index 0000000..c9d4950
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-10.c
@@ -0,0 +1,41 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, void * restrict mask_in, int l, int n, int m)
+{
+  vbool64_t mask = *(vbool64_t*)mask_in;
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j, 17);
+          __riscv_vse8_v_i8mf8 (out + i + j, v, 17);
+          vint8mf8_t v2 = __riscv_vle8_v_i8mf8_m (mask, in + i + j + 16, 17);
+          __riscv_vse8_v_i8mf8 (out + i + j + 16, v2, 17);
+        }
+    }
+  }
+}
+
+void f2 (void * restrict in, void * restrict out, void * restrict mask_in, int l, int n, int m)
+{
+  vbool8_t mask = *(vbool8_t*)mask_in;
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vfloat64m8_t v = __riscv_vle64_v_f64m8 (in + i + j, 17);
+          __riscv_vse64_v_f64m8 (out + i + j, v, 17);
+          vfloat64m8_t v2 = __riscv_vle64_v_f64m8_m (mask, in + i + j + 16, 17);
+          __riscv_vse64_v_f64m8 (out + i + j + 16, v2, 17);
+        }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle8\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle64\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e64,\s*m8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-11.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-11.c
new file mode 100644
index 0000000..2e8647e
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-11.c
@@ -0,0 +1,41 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, void * restrict mask_in, int l, int n, int m)
+{
+  vbool64_t mask = *(vbool64_t*)mask_in;
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j, 17);
+          __riscv_vse8_v_i8mf8 (out + i + j, v, 17);
+          vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tumu (mask, v, in + i + j + 16, 17);
+          __riscv_vse8_v_i8mf8 (out + i + j + 16, v2, 17);
+        }
+    }
+  }
+}
+
+void f2 (void * restrict in, void * restrict out, void * restrict mask_in, int l, int n, int m)
+{
+  vbool8_t mask = *(vbool8_t*)mask_in;
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vfloat64m8_t v = __riscv_vle64_v_f64m8 (in + i + j, 17);
+          __riscv_vse64_v_f64m8 (out + i + j, v, 17);
+          vfloat64m8_t v2 = __riscv_vle64_v_f64m8_tumu (mask, v, in + i + j + 16, 17);
+          __riscv_vse64_v_f64m8 (out + i + j + 16, v2, 17);
+        }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle8\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e8,\s*mf8,\s*tu,\s*mu} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle64\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e64,\s*m8,\s*tu,\s*mu} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-12.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-12.c
new file mode 100644
index 0000000..c1af8fc
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-12.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int n)
+{
+  vint8mf8_t v = __riscv_vle8_v_i8mf8(in + 100, 4);
+  vint8mf8_t v1 = __riscv_vle8_v_i8mf8(in + 1, 4);
+  vint16mf4_t v2 = __riscv_vle16_v_i16mf4(in + 2, 4);
+  vint32mf2_t v3 = __riscv_vle32_v_i32mf2(in + 3, 4);
+  vfloat32mf2_t v4 = __riscv_vle32_v_f32mf2(in + 4, 4);
+  
+  __riscv_vse8_v_i8mf8 (out + 1, v1, 4);
+  __riscv_vse16_v_i16mf4 (out + 2, v2, 4);
+  __riscv_vse32_v_i32mf2 (out + 3, v3, 4);
+  __riscv_vse32_v_f32mf2 (out + 4, v4, 4);
+  
+  for (int i = 0; i < n; i++)
+    {
+      v = __riscv_vle8_v_i8mf8_tu(v, in + i + 5, 4);
+      __riscv_vse8_v_i8mf8 (out + i + 5, v, 4);
+    }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle8\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*4,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-13.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-13.c
new file mode 100644
index 0000000..9abcc0f
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-13.c
@@ -0,0 +1,30 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, void * restrict mask_in, int n)
+{
+  vbool64_t mask = *(vbool64_t*)mask_in;
+  vint8mf8_t v1 = __riscv_vle8_v_i8mf8(in + 1, 4);
+  vint16mf4_t v2 = __riscv_vle16_v_i16mf4(in + 2, 4);
+  vint32mf2_t v3 = __riscv_vle32_v_i32mf2(in + 3, 4);
+  vfloat32mf2_t v4 = __riscv_vle32_v_f32mf2(in + 4, 4);
+  vint16mf4_t v = __riscv_vle16_v_i16mf4(in + 100, 4);
+  
+  __riscv_vse8_v_i8mf8 (out + 1, v1, 4);
+  __riscv_vse16_v_i16mf4 (out + 2, v2, 4);
+  __riscv_vse32_v_i32mf2 (out + 3, v3, 4);
+  __riscv_vse32_v_f32mf2 (out + 4, v4, 4);
+  
+  for (int i = 0; i < n; i++)
+    {
+      v = __riscv_vle16_v_i16mf4_tum(mask, v, in + i + 5, 4);
+      __riscv_vse16_v_i16mf4_m (mask, out + i + 5, v, 4);
+    }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle16\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\),\s*v0.t} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*4,\s*e16,\s*mf4,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-14.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-14.c
new file mode 100644
index 0000000..c917124
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-14.c
@@ -0,0 +1,31 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, void * restrict mask_in, int n)
+{
+  vbool32_t mask = *(vbool32_t*)mask_in;
+  vint8mf8_t v1 = __riscv_vle8_v_i8mf8(in + 1, 4);
+  vint16mf4_t v2 = __riscv_vle16_v_i16mf4(in + 2, 4);
+  vint32mf2_t v3 = __riscv_vle32_v_i32mf2(in + 3, 4);
+  vfloat32mf2_t v4 = __riscv_vle32_v_f32mf2(in + 4, 4);
+  
+  __riscv_vse8_v_i8mf8 (out + 1, v1, 4);
+  __riscv_vse16_v_i16mf4 (out + 2, v2, 4);
+  __riscv_vse32_v_i32mf2 (out + 3, v3, 4);
+  __riscv_vse32_v_f32mf2 (out + 4, v4, 4);
+
+  vint16mf2_t v = __riscv_vle16_v_i16mf2(in + 100, 4);
+  
+  for (int i = 0; i < n; i++)
+    {
+      v = __riscv_vle16_v_i16mf2_tumu(mask, v, in + i + 5, 4);
+      __riscv_vse16_v_i16mf2_m (mask, out + i + 5, v, 4);
+    }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle16\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\),\s*v0.t} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*4,\s*e16,\s*mf2,\s*tu,\s*mu} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-15.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-15.c
new file mode 100644
index 0000000..6256e2e
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-15.c
@@ -0,0 +1,32 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, void * restrict mask_in, int n)
+{
+  vbool32_t mask = *(vbool32_t*)mask_in;
+  vint8mf8_t v1 = __riscv_vle8_v_i8mf8(in + 1, 4);
+  vint16mf4_t v2 = __riscv_vle16_v_i16mf4(in + 2, 4);
+  vint32mf2_t v3 = __riscv_vle32_v_i32mf2(in + 3, 4);
+  vfloat32mf2_t v4 = __riscv_vle32_v_f32mf2(in + 4, 4);
+  
+  __riscv_vse8_v_i8mf8 (out + 1, v1, 4);
+  __riscv_vse16_v_i16mf4 (out + 2, v2, 4);
+  __riscv_vse32_v_i32mf2 (out + 3, v3, 4);
+  __riscv_vse32_v_f32mf2 (out + 4, v4, 4);
+
+  vint16mf2_t v = __riscv_vle16_v_i16mf2(in + 100, 4);
+  
+  for (int i = 0; i < n; i++)
+    {
+      v = __riscv_vle16_v_i16mf2_mu(mask, v, in + i + 5, 4);
+      __riscv_vse16_v_i16mf2_m (mask, out + i + 5, v, 4);
+    }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle16\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\),\s*v0.t} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*4,\s*e16,\s*mf2,\s*t[au],\s*mu} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-16.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-16.c
new file mode 100644
index 0000000..b936d72
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-16.c
@@ -0,0 +1,29 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, void * restrict mask_in, int n)
+{
+  vbool64_t mask = *(vbool64_t*)mask_in;
+  vint8mf8_t v1 = __riscv_vle8_v_i8mf8(in + 1, 4);
+  vint16mf4_t v2 = __riscv_vle16_v_i16mf4(in + 2, 4);
+  vint32mf2_t v3 = __riscv_vle32_v_i32mf2(in + 3, 4);
+  vfloat32mf2_t v4 = __riscv_vle32_v_f32mf2(in + 4, 4);
+  
+  __riscv_vse8_v_i8mf8 (out + 1, v1, 4);
+  __riscv_vse16_v_i16mf4 (out + 2, v2, 4);
+  __riscv_vse32_v_i32mf2 (out + 3, v3, 4);
+  __riscv_vse32_v_f32mf2 (out + 4, v4, 4);
+
+  for (int i = 0; i < n; i++)
+    {
+      vuint16mf4_t v = __riscv_vle16_v_u16mf4_m(mask, in + i + 5, 4);
+      __riscv_vse16_v_u16mf4_m (mask, out + i + 5, v, 4);
+    }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle16\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\),\s*v0.t} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*4,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-17.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-17.c
new file mode 100644
index 0000000..a8c19a2
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-17.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      vint8mf2_t v = __riscv_vle8_v_i8mf2 (in + i*10 + j*10, 8);
+      __riscv_vse8_v_i8mf2 (out + i*10 + j*10, v, 8);
+      for (int k = 0; k < n; k++)
+        {
+          vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j + k, 17);
+          __riscv_vse8_v_i8mf8 (out + i + j + k, v, 17);
+        }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*8,\s*e8,\s*mf2,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-2.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-2.c
new file mode 100644
index 0000000..32f3394
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-2.c
@@ -0,0 +1,168 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f3 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint16mf4_t v = __riscv_vle16_v_i16mf4 (in + i + j, 17);
+          __riscv_vse16_v_i16mf4 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f4 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vuint16mf4_t v = __riscv_vle16_v_u16mf4 (in + i + j, 17);
+          __riscv_vse16_v_u16mf4 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f5 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint16mf2_t v = __riscv_vle16_v_i16mf2 (in + i + j, 17);
+          __riscv_vse16_v_i16mf2 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f6 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vuint16mf2_t v = __riscv_vle16_v_u16mf2 (in + i + j, 17);
+          __riscv_vse16_v_u16mf2 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f7 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint16m1_t v = __riscv_vle16_v_i16m1 (in + i + j, 17);
+          __riscv_vse16_v_i16m1 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f8 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vuint16m1_t v = __riscv_vle16_v_u16m1 (in + i + j, 17);
+          __riscv_vse16_v_u16m1 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f9 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint16m2_t v = __riscv_vle16_v_i16m2 (in + i + j, 17);
+          __riscv_vse16_v_i16m2 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f10 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vuint16m2_t v = __riscv_vle16_v_u16m2 (in + i + j, 17);
+          __riscv_vse16_v_u16m2 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f11 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint16m4_t v = __riscv_vle16_v_i16m4 (in + i + j, 17);
+          __riscv_vse16_v_i16m4 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f12 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vuint16m4_t v = __riscv_vle16_v_u16m4 (in + i + j, 17);
+          __riscv_vse16_v_u16m4 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f13 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint16m8_t v = __riscv_vle16_v_i16m8 (in + i + j, 17);
+          __riscv_vse16_v_i16m8 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f14 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vuint16m8_t v = __riscv_vle16_v_u16m8 (in + i + j, 17);
+          __riscv_vse16_v_u16m8 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle16\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 12 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e16,\s*mf4,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e16,\s*mf2,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e16,\s*m1,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e16,\s*m2,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e16,\s*m4,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e16,\s*m8,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-3.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-3.c
new file mode 100644
index 0000000..4d08475
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-3.c
@@ -0,0 +1,141 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f5 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint32mf2_t v = __riscv_vle32_v_i32mf2 (in + i + j, 17);
+          __riscv_vse32_v_i32mf2 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f6 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vuint32mf2_t v = __riscv_vle32_v_u32mf2 (in + i + j, 17);
+          __riscv_vse32_v_u32mf2 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f7 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint32m1_t v = __riscv_vle32_v_i32m1 (in + i + j, 17);
+          __riscv_vse32_v_i32m1 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f8 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vuint32m1_t v = __riscv_vle32_v_u32m1 (in + i + j, 17);
+          __riscv_vse32_v_u32m1 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f9 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint32m2_t v = __riscv_vle32_v_i32m2 (in + i + j, 17);
+          __riscv_vse32_v_i32m2 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f10 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vuint32m2_t v = __riscv_vle32_v_u32m2 (in + i + j, 17);
+          __riscv_vse32_v_u32m2 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f11 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint32m4_t v = __riscv_vle32_v_i32m4 (in + i + j, 17);
+          __riscv_vse32_v_i32m4 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f12 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vuint32m4_t v = __riscv_vle32_v_u32m4 (in + i + j, 17);
+          __riscv_vse32_v_u32m4 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f13 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint32m8_t v = __riscv_vle32_v_i32m8 (in + i + j, 17);
+          __riscv_vse32_v_i32m8 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f14 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vuint32m8_t v = __riscv_vle32_v_u32m8 (in + i + j, 17);
+          __riscv_vse32_v_u32m8 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle32\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 10 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e32,\s*m1,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e32,\s*m2,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e32,\s*m4,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e32,\s*m8,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-4.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-4.c
new file mode 100644
index 0000000..976d389
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-4.c
@@ -0,0 +1,77 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f5 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vfloat32mf2_t v = __riscv_vle32_v_f32mf2 (in + i + j, 17);
+          __riscv_vse32_v_f32mf2 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f7 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vfloat32m1_t v = __riscv_vle32_v_f32m1 (in + i + j, 17);
+          __riscv_vse32_v_f32m1 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f9 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vfloat32m2_t v = __riscv_vle32_v_f32m2 (in + i + j, 17);
+          __riscv_vse32_v_f32m2 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f11 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vfloat32m4_t v = __riscv_vle32_v_f32m4 (in + i + j, 17);
+          __riscv_vse32_v_f32m4 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f13 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vfloat32m8_t v = __riscv_vle32_v_f32m8 (in + i + j, 17);
+          __riscv_vse32_v_f32m8 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle32\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 5 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e32,\s*m1,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e32,\s*m2,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e32,\s*m4,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e32,\s*m8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-5.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-5.c
new file mode 100644
index 0000000..defeb86
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-5.c
@@ -0,0 +1,114 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f7 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint64m1_t v = __riscv_vle64_v_i64m1 (in + i + j, 17);
+          __riscv_vse64_v_i64m1 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f8 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vuint64m1_t v = __riscv_vle64_v_u64m1 (in + i + j, 17);
+          __riscv_vse64_v_u64m1 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f9 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint64m2_t v = __riscv_vle64_v_i64m2 (in + i + j, 17);
+          __riscv_vse64_v_i64m2 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f10 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vuint64m2_t v = __riscv_vle64_v_u64m2 (in + i + j, 17);
+          __riscv_vse64_v_u64m2 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f11 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint64m4_t v = __riscv_vle64_v_i64m4 (in + i + j, 17);
+          __riscv_vse64_v_i64m4 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f12 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vuint64m4_t v = __riscv_vle64_v_u64m4 (in + i + j, 17);
+          __riscv_vse64_v_u64m4 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f13 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint64m8_t v = __riscv_vle64_v_i64m8 (in + i + j, 17);
+          __riscv_vse64_v_i64m8 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f14 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vuint64m8_t v = __riscv_vle64_v_u64m8 (in + i + j, 17);
+          __riscv_vse64_v_u64m8 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle64\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 8 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e64,\s*m1,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e64,\s*m2,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e64,\s*m4,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e64,\s*m8,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-6.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-6.c
new file mode 100644
index 0000000..1ae8a03
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-6.c
@@ -0,0 +1,64 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+
+void f8 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vfloat64m1_t v = __riscv_vle64_v_f64m1 (in + i + j, 17);
+          __riscv_vse64_v_f64m1 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f9 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vfloat64m2_t v = __riscv_vle64_v_f64m2 (in + i + j, 17);
+          __riscv_vse64_v_f64m2 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f11 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vfloat64m4_t v = __riscv_vle64_v_f64m4 (in + i + j, 17);
+          __riscv_vse64_v_f64m4 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+void f13 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vfloat64m8_t v = __riscv_vle64_v_f64m8 (in + i + j, 17);
+          __riscv_vse64_v_f64m8 (out + i + j, v, 17);
+        }
+    }
+  }
+}
+
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle64\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 4 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e64,\s*m1,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e64,\s*m2,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e64,\s*m4,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e64,\s*m8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-7.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-7.c
new file mode 100644
index 0000000..ac943abe
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-7.c
@@ -0,0 +1,39 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j, 17);
+          __riscv_vse8_v_i8mf8 (out + i + j, v, 17);
+          vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + i + j + 16, 17);
+          __riscv_vse8_v_i8mf8 (out + i + j + 16, v2, 17);
+        }
+    }
+  }
+}
+
+void f2 (void * restrict in, void * restrict out, int l, int n, int m)
+{
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vfloat64m8_t v = __riscv_vle64_v_f64m8 (in + i + j, 17);
+          __riscv_vse64_v_f64m8 (out + i + j, v, 17);
+          vfloat64m8_t v2 = __riscv_vle64_v_f64m8_tu (v, in + i + j + 16, 17);
+          __riscv_vse64_v_f64m8 (out + i + j + 16, v2, 17);
+        }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle8\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle64\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e64,\s*m8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-8.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-8.c
new file mode 100644
index 0000000..731930e
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-8.c
@@ -0,0 +1,45 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, void * restrict mask_in, int l, int n, int m)
+{
+  vbool64_t mask = *(vbool64_t*)mask_in;
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j, 17);
+          __riscv_vse8_v_i8mf8 (out + i + j, v, 17);
+          vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tu (v, in + i + j + 16, 17);
+          __riscv_vse8_v_i8mf8 (out + i + j + 16, v2, 17);
+          vint8mf8_t v3 = __riscv_vle8_v_i8mf8_mu (mask, v2, in + i + j + 16, 17);
+          __riscv_vse8_v_i8mf8 (out + i + j + 16, v3, 17);
+        }
+    }
+  }
+}
+
+void f2 (void * restrict in, void * restrict out, void * restrict mask_in, int l, int n, int m)
+{
+  vbool8_t mask = *(vbool8_t*)mask_in;
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vfloat64m8_t v = __riscv_vle64_v_f64m8 (in + i + j, 17);
+          __riscv_vse64_v_f64m8 (out + i + j, v, 17);
+          vfloat64m8_t v2 = __riscv_vle64_v_f64m8_tu (v, in + i + j + 16, 17);
+          __riscv_vse64_v_f64m8 (out + i + j + 16, v2, 17);
+          vfloat64m8_t v3 = __riscv_vle64_v_f64m8_mu (mask, v2, in + i + j + 16, 17);
+          __riscv_vse64_v_f64m8 (out + i + j + 16, v3, 17);
+        }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle8\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e8,\s*mf8,\s*tu,\s*mu} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle64\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e64,\s*m8,\s*tu,\s*mu} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-9.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-9.c
new file mode 100644
index 0000000..2dfca07
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_loop_invariant-9.c
@@ -0,0 +1,41 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, void * restrict mask_in, int l, int n, int m)
+{
+  vbool64_t mask = *(vbool64_t*)mask_in;
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vint8mf8_t v = __riscv_vle8_v_i8mf8 (in + i + j, 17);
+          __riscv_vse8_v_i8mf8 (out + i + j, v, 17);
+          vint8mf8_t v2 = __riscv_vle8_v_i8mf8_tum (mask, v, in + i + j + 16, 17);
+          __riscv_vse8_v_i8mf8 (out + i + j + 16, v2, 17);
+        }
+    }
+  }
+}
+
+void f2 (void * restrict in, void * restrict out, void * restrict mask_in, int l, int n, int m)
+{
+  vbool8_t mask = *(vbool8_t*)mask_in;
+  for (int i = 0; i < l; i++){
+    for (int j = 0; j < m; j++){
+      for (int k = 0; k < n; k++)
+        {
+          vfloat64m8_t v = __riscv_vle64_v_f64m8 (in + i + j, 17);
+          __riscv_vse64_v_f64m8 (out + i + j, v, 17);
+          vfloat64m8_t v2 = __riscv_vle64_v_f64m8_tum (mask, v, in + i + j + 16, 17);
+          __riscv_vse64_v_f64m8 (out + i + j + 16, v2, 17);
+        }
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle8\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle64\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e64,\s*m8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_switch-1.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_switch-1.c
new file mode 100644
index 0000000..b084eea
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_switch-1.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int n)
+{
+  vfloat32mf2_t v = __riscv_vle32_v_f32mf2 (in + 10000, 19);
+  __riscv_vse32_v_f32mf2 (out + 10000, v, 19);
+  for (int i = 0; i < n; i++)
+    {
+      vint16mf2_t v1 = __riscv_vle16_v_i16mf2 (in + i + 1, 19);
+      __riscv_vse16_v_i16mf2 (out + i + 1, v1, 19);
+      asm volatile ("":::"memory");
+      vint32mf2_t v2 = __riscv_vle32_v_i32mf2 (in + i + 2, 19);
+      __riscv_vse32_v_i32mf2 (out + i + 2, v2, 19);
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*19,\s*e16,\s*mf2,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*19,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_switch-2.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_switch-2.c
new file mode 100644
index 0000000..2e58f08
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_switch-2.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, void * restrict mask_in, int n)
+{
+  vfloat32mf2_t v = __riscv_vle32_v_f32mf2 (in + 10000, 19);
+  __riscv_vse32_v_f32mf2 (out + 10000, v, 19);
+  for (int i = 0; i < n; i++)
+    {
+      vint16mf2_t v1 = __riscv_vle16_v_i16mf2 (in + i + 1, 19);
+      __riscv_vse16_v_i16mf2 (out + i + 1, v1, 19);
+      vint32mf2_t v2 = __riscv_vle32_v_i32mf2 (in + i + 2, 19);
+      __riscv_vse32_v_i32mf2 (out + i + 2, v2, 19);
+      vbool64_t mask = *(vbool64_t*)mask_in;
+      vint32mf2_t v3 = __riscv_vle32_v_i32mf2_tumu (mask, v2, in + i + 200, 13);
+      *(vint32mf2_t*)(out + i + 200) = v3;
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*13,\s*e32,\s*mf2,\s*tu,\s*mu} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*19,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*19,\s*e16,\s*mf2,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli} 4 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_switch-3.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_switch-3.c
new file mode 100644
index 0000000..a751700
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_switch-3.c
@@ -0,0 +1,189 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-move-loop-invariants" } */
+
+#include "riscv_vector.h"
+
+void f (int * restrict in, int * restrict out, void * restrict mask_in, int n)
+{
+  vbool64_t mask = *(vbool64_t*)mask_in;
+  for (int i = 0; i < n; i++)
+    {
+      vint8mf8_t v_8mf8_0 = __riscv_vle8_v_i8mf8 ((int8_t *)(in + i), 0);
+      __riscv_vse8_v_i8mf8 ((int8_t *)(out + i), v_8mf8_0, 0);
+
+      vint8mf8_t v_8mf8_0_tu = __riscv_vle8_v_i8mf8_tu (v_8mf8_0, (int8_t *)(in + i + 1), 0);
+      __riscv_vse8_v_i8mf8_m (mask, (int8_t *)(out + i + 1), v_8mf8_0_tu, 0);
+
+      vint8mf8_t v_8mf8_0_mu = __riscv_vle8_v_i8mf8_mu (mask, v_8mf8_0, (int8_t *)(in + i + 2), 0);
+      __riscv_vse8_v_i8mf8 ((int8_t *)(out + i + 2), v_8mf8_0_tu, 0);
+
+      vint8mf8_t v_8mf8_1 = __riscv_vle8_v_i8mf8 ((int8_t *)(in + i + 3), 7);
+      __riscv_vse8_v_i8mf8 ((int8_t *)(out + i + 3), v_8mf8_1, 7);
+      
+      vint8mf8_t v_8mf8_2 = __riscv_vle8_v_i8mf8 ((int8_t *)(in + i + 4), 17);
+      __riscv_vse8_v_i8mf8 ((int8_t *)(out + i + 4), v_8mf8_2, 17);
+
+      vint8mf8_t v_8mf8_3 = __riscv_vle8_v_i8mf8 ((int8_t *)(in + i + 5), 27);
+      __riscv_vse8_v_i8mf8 ((int8_t *)(out + i + 5), v_8mf8_3, 27);
+
+      vint8mf4_t v_8mf4_1 = __riscv_vle8_v_i8mf4 ((int8_t *)(in + i + 6), 7);
+      __riscv_vse8_v_i8mf4 ((int8_t *)(out + i + 6), v_8mf4_1, 7);
+      
+      vint8mf4_t v_8mf4_2 = __riscv_vle8_v_i8mf4 ((int8_t *)(in + i + 7), 17);
+      __riscv_vse8_v_i8mf4 ((int8_t *)(out + i + 7), v_8mf4_2, 17);
+
+      vint8mf4_t v_8mf4_3 = __riscv_vle8_v_i8mf4 ((int8_t *)(in + i + 8), 27);
+      __riscv_vse8_v_i8mf4 ((int8_t *)(out + i + 8), v_8mf4_3, 27);
+
+      vint8mf2_t v_8mf2_1 = __riscv_vle8_v_i8mf2 ((int8_t *)(in + i + 9), 7);
+      __riscv_vse8_v_i8mf2 ((int8_t *)(out + i + 9), v_8mf2_1, 7);
+      
+      vint8mf2_t v_8mf2_2 = __riscv_vle8_v_i8mf2 ((int8_t *)(in + i + 10), 17);
+      __riscv_vse8_v_i8mf2 ((int8_t *)(out + i + 10), v_8mf2_2, 17);
+
+      vint8mf2_t v_8mf2_3 = __riscv_vle8_v_i8mf2 ((int8_t *)(in + i + 11), 27);
+      __riscv_vse8_v_i8mf2 ((int8_t *)(out + i + 11), v_8mf2_3, 27);
+
+      vint8m1_t v_8m1_1 = __riscv_vle8_v_i8m1 ((int8_t *)(in + i + 12), 7);
+      __riscv_vse8_v_i8m1 ((int8_t *)(out + i + 12), v_8m1_1, 7);
+      
+      vint8m1_t v_8m1_2 = __riscv_vle8_v_i8m1 ((int8_t *)(in + i + 13), 17);
+      __riscv_vse8_v_i8m1 ((int8_t *)(out + i + 13), v_8m1_2, 17);
+
+      vint8m1_t v_8m1_3 = __riscv_vle8_v_i8m1 ((int8_t *)(in + i + 14), 27);
+      __riscv_vse8_v_i8m1 ((int8_t *)(out + i + 14), v_8m1_3, 27);
+
+      vint8m2_t v_8m2_1 = __riscv_vle8_v_i8m2 ((int8_t *)(in + i + 15), 7);
+      __riscv_vse8_v_i8m2 ((int8_t *)(out + i + 15), v_8m2_1, 7);
+      
+      vint8m2_t v_8m2_2 = __riscv_vle8_v_i8m2 ((int8_t *)(in + i + 16), 17);
+      __riscv_vse8_v_i8m2 ((int8_t *)(out + i + 16), v_8m2_2, 17);
+
+      vint8m2_t v_8m2_3 = __riscv_vle8_v_i8m2 ((int8_t *)(in + i + 17), 27);
+      __riscv_vse8_v_i8m2 ((int8_t *)(out + i + 17), v_8m2_3, 27);
+
+      vint8m4_t v_8m4_1 = __riscv_vle8_v_i8m4 ((int8_t *)(in + i + 18), 7);
+      __riscv_vse8_v_i8m4 ((int8_t *)(out + i + 18), v_8m4_1, 7);
+      
+      vint8m4_t v_8m4_2 = __riscv_vle8_v_i8m4 ((int8_t *)(in + i + 19), 17);
+      __riscv_vse8_v_i8m4 ((int8_t *)(out + i + 19), v_8m4_2, 17);
+
+      vint8m4_t v_8m4_3 = __riscv_vle8_v_i8m4 ((int8_t *)(in + i + 20), 27);
+      __riscv_vse8_v_i8m4 ((int8_t *)(out + i + 20), v_8m4_3, 27);
+
+      vint8m8_t v_8m8_1 = __riscv_vle8_v_i8m8 ((int8_t *)(in + i + 21), 7);
+      __riscv_vse8_v_i8m8 ((int8_t *)(out + i + 21), v_8m8_1, 7);
+      
+      vint8m8_t v_8m8_2 = __riscv_vle8_v_i8m8 ((int8_t *)(in + i + 22), 17);
+      __riscv_vse8_v_i8m8 ((int8_t *)(out + i + 22), v_8m8_2, 17);
+
+      vint8m8_t v_8m8_3 = __riscv_vle8_v_i8m8 ((int8_t *)(in + i + 23), 27);
+      __riscv_vse8_v_i8m8 ((int8_t *)(out + i + 23), v_8m8_3, 27);
+
+      vuint16mf4_t v_16mf4_1 = *(vuint16mf4_t*)(in + 24 + i);
+      *(vuint16mf4_t*)(out + 24 + i) = v_16mf4_1;
+      
+      vuint16mf2_t v_16mf2_1 = *(vuint16mf2_t*)(in + 25 + i);
+      *(vuint16mf2_t*)(out + 25 + i) = v_16mf2_1;
+
+      vuint32mf2_t v_32mf2_t = *(vuint32mf2_t*)(in + 26 + i);
+      *(vuint32mf2_t*)(out + 26 + i) = v_32mf2_t;
+
+      vuint8mf2_t v_8mf2_4 = *(vuint8mf2_t*)(in + 27 + i);
+      *(vuint8mf2_t*)(out + 27 + i) = v_8mf2_4;
+
+      vuint8mf4_t v_8mf4_4 = *(vuint8mf4_t*)(in + 28 + i);
+      *(vuint8mf4_t*)(out + 28 + i) = v_8mf4_4;
+
+      vint32mf2_t v_32mf2_1 = __riscv_vle32_v_i32mf2 ((int32_t *)(in + i + 49), 7);
+      __riscv_vse32_v_i32mf2 ((int32_t *)(out + i + 49), v_32mf2_1, 7);
+      
+      vint32mf2_t v_32mf2_2 = __riscv_vle32_v_i32mf2 ((int32_t *)(in + i + 30), 17);
+      __riscv_vse32_v_i32mf2 ((int32_t *)(out + i + 30), v_32mf2_2, 17);
+
+      vint32mf2_t v_32mf2_3 = __riscv_vle32_v_i32mf2 ((int32_t *)(in + i + 31), 27);
+      __riscv_vse32_v_i32mf2 ((int32_t *)(out + i + 31), v_32mf2_3, 27);
+
+      vint32m1_t v_32m1_1 = __riscv_vle32_v_i32m1 ((int32_t *)(in + i + 32), 7);
+      __riscv_vse32_v_i32m1 ((int32_t *)(out + i + 32), v_32m1_1, 7);
+      
+      vint32m1_t v_32m1_2 = __riscv_vle32_v_i32m1 ((int32_t *)(in + i + 33), 17);
+      __riscv_vse32_v_i32m1 ((int32_t *)(out + i + 33), v_32m1_2, 17);
+
+      vint32m1_t v_32m1_3 = __riscv_vle32_v_i32m1 ((int32_t *)(in + i + 34), 27);
+      __riscv_vse32_v_i32m1 ((int32_t *)(out + i + 34), v_32m1_3, 27);
+
+      vint32m2_t v_32m2_1 = __riscv_vle32_v_i32m2 ((int32_t *)(in + i + 35), 7);
+      __riscv_vse32_v_i32m2 ((int32_t *)(out + i + 35), v_32m2_1, 7);
+      
+      vint32m2_t v_32m2_2 = __riscv_vle32_v_i32m2 ((int32_t *)(in + i + 36), 17);
+      __riscv_vse32_v_i32m2 ((int32_t *)(out + i + 36), v_32m2_2, 17);
+
+      vint32m2_t v_32m2_3 = __riscv_vle32_v_i32m2 ((int32_t *)(in + i + 37), 27);
+      __riscv_vse32_v_i32m2 ((int32_t *)(out + i + 37), v_32m2_3, 27);
+
+      vint32m4_t v_32m4_1 = __riscv_vle32_v_i32m4 ((int32_t *)(in + i + 38), 7);
+      __riscv_vse32_v_i32m4 ((int32_t *)(out + i + 38), v_32m4_1, 7);
+      
+      vint32m4_t v_32m4_2 = __riscv_vle32_v_i32m4 ((int32_t *)(in + i + 39), 17);
+      __riscv_vse32_v_i32m4 ((int32_t *)(out + i + 39), v_32m4_2, 17);
+
+      vint32m4_t v_32m4_3 = __riscv_vle32_v_i32m4 ((int32_t *)(in + i + 40), 27);
+      __riscv_vse32_v_i32m4 ((int32_t *)(out + i + 40), v_32m4_3, 27);
+
+      vint32m8_t v_32m8_1 = __riscv_vle32_v_i32m8 ((int32_t *)(in + i + 41), 7);
+      __riscv_vse32_v_i32m8 ((int32_t *)(out + i + 41), v_32m8_1, 7);
+      
+      vint32m8_t v_32m8_2 = __riscv_vle32_v_i32m8 ((int32_t *)(in + i + 42), 17);
+      __riscv_vse32_v_i32m8 ((int32_t *)(out + i + 42), v_32m8_2, 17);
+
+      vint32m8_t v_32m8_3 = __riscv_vle32_v_i32m8 ((int32_t *)(in + i + 43), 27);
+      __riscv_vse32_v_i32m8 ((int32_t *)(out + i + 43), v_32m8_3, 27);
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*0,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*7,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*27,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*7,\s*e8,\s*mf4,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e8,\s*mf4,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*27,\s*e8,\s*mf4,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*7,\s*e8,\s*mf2,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e8,\s*mf2,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*27,\s*e8,\s*mf2,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*7,\s*e8,\s*m1,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e8,\s*m1,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*27,\s*e8,\s*m1,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*7,\s*e8,\s*m2,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e8,\s*m2,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*27,\s*e8,\s*m2,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*7,\s*e8,\s*m4,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e8,\s*m4,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*27,\s*e8,\s*m4,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*7,\s*e8,\s*m8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e8,\s*m8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*27,\s*e8,\s*m8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf4,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf2,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*7,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*27,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*7,\s*e32,\s*m1,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e32,\s*m1,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*27,\s*e32,\s*m1,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*7,\s*e32,\s*m2,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e32,\s*m2,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*27,\s*e32,\s*m2,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*7,\s*e32,\s*m4,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e32,\s*m4,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*27,\s*e32,\s*m4,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*7,\s*e32,\s*m8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*17,\s*e32,\s*m8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*27,\s*e32,\s*m8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 6 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli} 37 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_switch-4.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_switch-4.c
new file mode 100644
index 0000000..b8aac96
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_switch-4.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int n)
+{
+  vint8mf8_t v1 = __riscv_vle8_v_i8mf8 (in + 1, 5);
+  vint16mf4_t v2 = __riscv_vle16_v_i16mf4 (in + 2, 5);
+  vint32mf2_t v3 = __riscv_vle32_v_i32mf2 (in + 3, 5);
+  vfloat32mf2_t v4 = __riscv_vle32_v_f32mf2 (in + 4, 5);
+  
+  __riscv_vse8_v_i8mf8 (out + 1, v1, 5);
+  __riscv_vse16_v_i16mf4 (out + 2, v2, 5);
+  __riscv_vse32_v_i32mf2 (out + 3, v3, 5);
+  __riscv_vse32_v_f32mf2 (out + 4, v4, 5);
+
+  for (int i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8_tu (v1, in + i + 5, 5);
+      __riscv_vse8_v_i8mf8 (out + i + 5, v, 5);
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*5,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_switch-5.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_switch-5.c
new file mode 100644
index 0000000..702326c
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_switch-5.c
@@ -0,0 +1,29 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void fn3 (void);
+
+void f (void * restrict in, void * restrict out, int n)
+{
+  vint8mf8_t v1 = __riscv_vle8_v_i8mf8 (in + 1, 5);
+  vint16mf4_t v2 = __riscv_vle16_v_i16mf4 (in + 2, 5);
+  vint32mf2_t v3 = __riscv_vle32_v_i32mf2 (in + 3, 5);
+  vfloat32mf2_t v4 = __riscv_vle32_v_f32mf2 (in + 4, 5);
+  
+  __riscv_vse8_v_i8mf8 (out + 1, v1, 5);
+  __riscv_vse16_v_i16mf4 (out + 2, v2, 5);
+  __riscv_vse32_v_i32mf2 (out + 3, v3, 5);
+  __riscv_vse32_v_f32mf2 (out + 4, v4, 5);
+
+  for (int i = 0; i < n; i++)
+    {
+      vint16mf4_t v = __riscv_vle16_v_i16mf4 (in + i + 5, 7);
+      __riscv_vse16_v_i16mf4 (out + i + 5, v, 7);
+      fn3 ();
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*5,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vsetivli\s+zero,\s*7,\s*e16,\s*mf4,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_switch-6.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_switch-6.c
new file mode 100644
index 0000000..cd776da
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_switch-6.c
@@ -0,0 +1,30 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void fn3 (void);
+
+void f (void * restrict in, void * restrict out, int n)
+{
+  vint8mf8_t v1 = __riscv_vle8_v_i8mf8 (in + 1, 5);
+  vint16mf4_t v2 = __riscv_vle16_v_i16mf4 (in + 2, 5);
+  vint32mf2_t v3 = __riscv_vle32_v_i32mf2 (in + 3, 5);
+  vfloat32mf2_t v4 = __riscv_vle32_v_f32mf2 (in + 4, 5);
+  
+  __riscv_vse8_v_i8mf8 (out + 1, v1, 5);
+  __riscv_vse16_v_i16mf4 (out + 2, v2, 5);
+  __riscv_vse32_v_i32mf2 (out + 3, v3, 5);
+  __riscv_vse32_v_f32mf2 (out + 4, v4, 5);
+
+  for (int i = 0; i < n; i++)
+    {
+      vint16mf4_t v = __riscv_vle16_v_i16mf4 (in + i + 5, 5);
+      __riscv_vse16_v_i16mf4 (out + i + 5, v, 5);
+      fn3 ();
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*5,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vsetivli\s+zero,\s*5,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+\.L[0-9]+} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_switch-7.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_switch-7.c
new file mode 100644
index 0000000..6795a1e
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_switch-7.c
@@ -0,0 +1,29 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int n)
+{
+  vint8mf8_t v1 = __riscv_vle8_v_i8mf8 (in + 1, 5);
+  vint16mf4_t v2 = __riscv_vle16_v_i16mf4 (in + 2, 5);
+  vint32mf2_t v3 = __riscv_vle32_v_i32mf2 (in + 3, 5);
+  vfloat32mf2_t v4 = __riscv_vle32_v_f32mf2 (in + 4, 5);
+  
+  __riscv_vse8_v_i8mf8 (out + 1, v1, 5);
+  __riscv_vse16_v_i16mf4 (out + 2, v2, 5);
+  __riscv_vse32_v_i32mf2 (out + 3, v3, 5);
+  __riscv_vse32_v_f32mf2 (out + 4, v4, 5);
+
+  for (int i = 0; i < n; i++)
+    {
+      vint16mf4_t v = __riscv_vle16_v_i16mf4 (in + i + 5, 5);
+      __riscv_vse16_v_i16mf4 (out + i + 5, v, 5);
+      vint16mf2_t v2 = __riscv_vle16_v_i16mf2 (in + i + 6, 8);
+      __riscv_vse16_v_i16mf2 (out + i + 6, v2, 8);
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*5,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vsetivli\s+zero,\s*5,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+\.L[0-9]+} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*8,\s*e16,\s*mf2,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_switch-8.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_switch-8.c
new file mode 100644
index 0000000..a4c8de7
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_switch-8.c
@@ -0,0 +1,35 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, int * restrict out2, int n)
+{
+  vint8mf8_t v1 = __riscv_vle8_v_i8mf8 (in + 1, 5);
+  vint16mf4_t v2 = __riscv_vle16_v_i16mf4 (in + 2, 5);
+  vint32mf2_t v3 = __riscv_vle32_v_i32mf2 (in + 3, 5);
+  vfloat32mf2_t v4 = __riscv_vle32_v_f32mf2 (in + 4, 5);
+  
+  __riscv_vse8_v_i8mf8 (out + 1, v1, 5);
+  __riscv_vse16_v_i16mf4 (out + 2, v2, 5);
+  __riscv_vse32_v_i32mf2 (out + 3, v3, 5);
+  __riscv_vse32_v_f32mf2 (out + 4, v4, 5);
+
+  for (int i = 0 ; i < n * n; i++)
+    out2[i] = out2[i] + out2[i];
+  
+  for (int i = 0 ; i < n * n * n; i++)
+    out2[i] = out2[i] * out2[i];
+
+  for (int i = 0 ; i < n * n * n * n; i++)
+    out2[i] = out2[i] * out2[i];
+
+  for (int i = 0; i < n; i++)
+    {
+      vint8mf8_t v = __riscv_vle8_v_i8mf8_tu (v1, in + i + 5, 5);
+      __riscv_vse8_v_i8mf8 (out + i + 5, v, 5);
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*5,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli} 1 { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_switch-9.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_switch-9.c
new file mode 100644
index 0000000..149f01b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/imm_switch-9.c
@@ -0,0 +1,47 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f (void * restrict in, void * restrict out, void * restrict mask_in, int n, int cond)
+{
+  vbool64_t mask = *(vbool64_t*)mask_in;
+  vfloat32mf2_t vf32mf2 = *(vfloat32mf2_t*)in;
+  vint16mf4_t vf16mf4 = *(vint16mf4_t*)(in + 5);
+  asm volatile ("":::"memory");
+  vfloat32mf2_t v = __riscv_vle32_v_f32mf2 (in + 10000, 5);
+  __riscv_vse32_v_f32mf2 (out + 10000, v, 5);
+
+  if (cond)
+    {
+      vfloat32mf2_t vt = __riscv_vle32_v_f32mf2_tumu (mask, vf32mf2, in + 20000, 5);
+      __riscv_vse32_v_f32mf2 (out + 20000, vt, 5);
+    }
+  else
+    {
+      vint16mf4_t vt = __riscv_vle16_v_i16mf4_tumu (mask, vf16mf4, in + 20000, 5);
+      __riscv_vse16_v_i16mf4 (out + 20000, vt, 5);
+    }
+
+  for (int i = 0; i < n; i++)
+    {
+      vfloat32mf2_t v0 = __riscv_vle32_v_f32mf2_tu (v, in + i + 100, 5);
+      vint16mf2_t v1 = __riscv_vle16_v_i16mf2 (in + i + 200, 6);
+      vint8mf2_t v2 = __riscv_vle8_v_i8mf2 (in + i + 300, 7);
+      vint8mf4_t v3 = __riscv_vle8_v_i8mf4 (in + i + 400, 8);
+      vint8mf8_t v4 = __riscv_vle8_v_i8mf8 (in + i + 500, 9);
+      vint32mf2_t v5 = __riscv_vle32_v_i32mf2 (in + i + 600, 5);
+      
+      __riscv_vse32_v_f32mf2 (out + i + 100, v0, 5);
+      __riscv_vse16_v_i16mf2 (out + i + 200, v1, 6);
+      __riscv_vse8_v_i8mf2 (out + i + 300, v2, 7);
+      __riscv_vse8_v_i8mf4 (out + i + 400, v3, 8);
+      __riscv_vse8_v_i8mf8 (out + i + 500, v4, 9);
+      __riscv_vse32_v_i32mf2 (out + i + 600, v5, 5);
+    }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*5,\s*e16,\s*mf4,\s*tu,\s*mu} 1 { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetivli\s+zero,\s*5,\s*e32,\s*mf2,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_back_prop-13.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_back_prop-13.c
index 31034bc..b819029 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_back_prop-13.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_back_prop-13.c
@@ -22,8 +22,8 @@ void f (int32_t * restrict in, int32_t * restrict out, int n, int cond, int cond
     *(vfloat32mf2_t*)(out + i + 500) = v;
   }
   for (int i = 0; i < n; i++) {
-    vfloat64m1_t v = *(vfloat64m1_t*)(in + 500 + i);
-    *(vfloat64m1_t*)(out + i + 600) = v;
+    vuint32mf2_t v = *(vuint32mf2_t*)(in + 500 + i);
+    *(vuint32mf2_t*)(out + i + 600) = v;
   }
 
   if (cond == 0)
@@ -58,7 +58,7 @@ void f (int32_t * restrict in, int32_t * restrict out, int n, int cond, int cond
   }
 }
 
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*m1,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli} 3 { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_back_prop-27.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_back_prop-27.c
index e148a1c..52e16d6 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_back_prop-27.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_back_prop-27.c
@@ -38,7 +38,7 @@ void f (void * restrict in, void * restrict out, void * restrict in2, void * res
   }
 }
 
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
@@ -48,4 +48,4 @@ void f (void * restrict in, void * restrict out, void * restrict in2, void * res
 
 /* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*zero,\s*e16,\s*mf4,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli} 9 { target { no-opts "-O0"  no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 10 { target { no-opts "-O0"  no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_back_prop-28.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_back_prop-28.c
index e8340a6..98df1fc 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_back_prop-28.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_back_prop-28.c
@@ -40,7 +40,7 @@ void f (void * restrict in, void * restrict out, void * restrict in2, void * res
   }
 }
 
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
@@ -51,4 +51,4 @@ void f (void * restrict in, void * restrict out, void * restrict in2, void * res
 /* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*zero,\s*e16,\s*mf4,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli} 10 { target { no-opts "-O0"  no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 11 { target { no-opts "-O0"  no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_back_prop-45.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_back_prop-45.c
index 0f6b96e..3c2b527 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_back_prop-45.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_back_prop-45.c
@@ -30,5 +30,5 @@ void foo5_5 (int32_t * restrict in, int32_t * restrict out, size_t n, size_t m,
     }
 }
 
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+j\s+\.L[0-9]+} 1 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+j\s+\.L[0-9]+} 1 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0"  no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-13.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-13.c
index bcf8e1c..d7c74fe 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-13.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-13.c
@@ -210,12 +210,6 @@ void f6 (int8_t * restrict in, int8_t * restrict out, int n)
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle8\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle8\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle8\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf4,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf2,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle16\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle16\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle32\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-14.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-14.c
index c2a8c3b..9ea35cf 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-14.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-14.c
@@ -210,12 +210,6 @@ void f6 (int8_t * restrict in, int8_t * restrict out, int n)
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle8\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle8\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle8\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf4,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf2,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle16\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle16\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle32\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-15.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-15.c
index e449078..5c4a031 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-15.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-15.c
@@ -38,4 +38,3 @@ void f (int8_t * restrict in, int8_t * restrict out, int n)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle32\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-16.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-16.c
index 224fc2e..fe7870e 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-16.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-16.c
@@ -248,10 +248,3 @@ void f7 (int8_t * restrict in, int8_t * restrict out, int n)
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m2,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m4,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m8,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vlm\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vlm\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vlm\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vlm\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vlm\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vlm\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+\.L[0-9][0-9][0-9]\:\s+vlm\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-21.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-21.c
index 198b72f..d564b06 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-21.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-21.c
@@ -147,9 +147,9 @@ void f6 (int * restrict in, int * restrict out, int n, int cond)
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf4,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf2,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+\.L[0-9]\:\s+vle8\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle8\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle8\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle16\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle16\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle32\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+\.L[0-9]\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-22.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-22.c
index ca20f2f..fe32d83 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-22.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-22.c
@@ -147,9 +147,9 @@ void f6 (int * restrict in, int * restrict out, int n, int cond)
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf4,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf2,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+\.L[0-9]\:\s+vle8\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle8\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle8\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle16\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle16\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle32\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+\.L[0-9]\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-23.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-23.c
index ecd8a20..3271557 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-23.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-23.c
@@ -27,4 +27,4 @@ void f (int * restrict in, int * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9]\:\s+vle32\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9]\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-24.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-24.c
index a9ed211..233bb0b 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-24.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-24.c
@@ -171,10 +171,10 @@ void f7 (int * restrict in, int * restrict out, int n, int cond)
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m2,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m4,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m8,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+\.L[0-9]\:\s+vlm\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vlm\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vlm\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vlm\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vlm\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vlm\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vlm\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+\.L[0-9]\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-25.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-25.c
index f87a8cc..13aa25e 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-25.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-25.c
@@ -563,10 +563,10 @@ void f7 (int8_t * restrict in, int8_t * restrict out, int n)
   }
 }
 
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m1,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m2,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m4,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m8,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m1,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m2,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m4,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m8,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-26.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-26.c
index c123855..a5e065d 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-26.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-26.c
@@ -483,10 +483,10 @@ void f6 (int8_t * restrict in, int8_t * restrict out, int n)
   }
 }
 
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf4,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf2,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf4,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf2,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-27.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-27.c
index 6265000..9275951 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-27.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-27.c
@@ -483,9 +483,9 @@ void f6 (int8_t * restrict in, int8_t * restrict out, int n)
   }
 }
 
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf4,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf2,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf4,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf2,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-28.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-28.c
index de7c5f9..cbb4501 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-28.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-28.c
@@ -83,4 +83,4 @@ void f6 (int8_t * restrict in, int8_t * restrict out, int n)
   }
 }
 
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-3.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-3.c
index f920017..ad89899 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-3.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-3.c
@@ -31,5 +31,5 @@ void f (int8_t * restrict in, int8_t * restrict out, int n)
   }
 }
 
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {add\ta[0-7],a[0-7],a[0-7]\s+\.L[0-9][0-9]\:\s+vle32\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-5.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-5.c
index 2cf28d7..83b7aaf 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-5.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-5.c
@@ -156,12 +156,12 @@ void f6 (int8_t * restrict in, int8_t * restrict out, int n)
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle8\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle8\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle8\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+\.L[0-9]+\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+\.L[0-9]+\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9]+\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf4,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf2,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle16\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle16\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+\.L[0-9]+\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9]+\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle32\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9]+\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-6.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-6.c
index d52c1bb..d3be701 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-6.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-6.c
@@ -156,12 +156,12 @@ void f6 (int8_t * restrict in, int8_t * restrict out, int n)
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle8\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle8\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle8\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+\.L[0-9]+\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+\.L[0-9]+\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9]+\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf4,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf2,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle16\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle16\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+\.L[0-9]+\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9]+\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle32\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9]+\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-7.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-7.c
index bd6d68b..c3f8684 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-7.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-7.c
@@ -29,4 +29,4 @@ void f (int8_t * restrict in, int8_t * restrict out, int n)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vle32\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9]+\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-8.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-8.c
index d3b3fa3..2487593 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-8.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_bb_prop-8.c
@@ -185,10 +185,10 @@ void f7 (int8_t * restrict in, int8_t * restrict out, int n)
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m2,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m4,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m8,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vlm\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vlm\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vlm\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vlm\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vlm\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+\.L[0-9][0-9]\:\s+vlm\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+\.L[0-9][0-9][0-9]\:\s+vlm\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+\.L[0-9]+\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+\.L[0-9]+\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9]+\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+\.L[0-9]+\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+\.L[0-9]+\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+\.L[0-9]+\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+\.L[0-9]+\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-O1" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_conflict-1.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_conflict-1.c
index 34ac4a5..7a8bb8e 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_conflict-1.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_conflict-1.c
@@ -1,5 +1,5 @@
 /* { dg-do compile } */
-/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize" } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-tree-vectorize -fno-schedule-insns -fno-schedule-insns2" } */
 
 #include "riscv_vector.h"
 
@@ -18,6 +18,6 @@ void f (int32_t * restrict in, int32_t * restrict out, size_t n, size_t cond, si
 }
 
 /* { dg-final { scan-assembler-times {vsetvli} 3 { target { no-opts "-O0" no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {\.L[0-9]+:\s+vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+\.L[0-9]+} 1 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+\.L[0-9]+\:} 1 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+j\s+\.L[0-9]+} 1 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_conflict-6.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_conflict-6.c
index 217ce11..d365e4a 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_conflict-6.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_conflict-6.c
@@ -19,7 +19,6 @@ void f (int32_t * in, int32_t * out, int n, int cond)
   }
 }
 
-/* { dg-final { scan-assembler-times {\.L[0-9]+:\s+vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+\.L[0-9]+:} 1 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {\.L[0-9]+:\s+vle8\.v} 1 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf2,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_conflict-7.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_conflict-7.c
index 05058b8..46f6292 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_conflict-7.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_conflict-7.c
@@ -23,4 +23,3 @@ void f (int32_t * restrict in, int32_t * restrict out, size_t n, size_t cond, si
 /* { dg-final { scan-assembler-times {vsetvli} 4 { target { no-opts "-O0"  no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {j\s+\.L[0-9]+\s+\.L[0-9]+:\s+vlm\.v} 1 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m8,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-1.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-1.c
index db5f64f..aaafa02 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-1.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-1.c
@@ -29,4 +29,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"   no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+\.L[0-9]\:} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-10.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-10.c
index d5c108c..200bec7 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-10.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-10.c
@@ -29,4 +29,3 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf2,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"   no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9]\:} 1 { target { no-opts "-O0"   no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-11.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-11.c
index 2c8e0ba..f8bf5eb 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-11.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-11.c
@@ -29,4 +29,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"   no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9]\:} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-12.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-12.c
index 50807ad..691ff24 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-12.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-12.c
@@ -29,4 +29,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"   no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9]\:} 1 { target { no-opts "-O0"   no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-13.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-13.c
index b9e0d20..b922c43 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-13.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-13.c
@@ -29,4 +29,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"   no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9]\:} 1 { target { no-opts "-O0"   no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-14.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-14.c
index efe51b2..d1be90a 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-14.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-14.c
@@ -180,10 +180,4 @@ void f7 (void * restrict in, void * restrict out, int n, int cond)
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m4,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"   no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m8,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"   no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+\.L[0-9]+\:} 1 { target { no-opts "-O0"   no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+\.L[0-9]+\:} 1 { target { no-opts "-O0"   no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9]+\:} 1 { target { no-opts "-O0"   no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m1,\s*t[au],\s*m[au]\s+\.L[0-9]+\:} 1 { target { no-opts "-O0"   no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m2,\s*t[au],\s*m[au]\s+\.L[0-9]+\:} 1 { target { no-opts "-O0"   no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m4,\s*t[au],\s*m[au]\s+\.L[0-9]+\:} 1 { target { no-opts "-O0"   no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m8,\s*t[au],\s*m[au]\s+\.L[0-9]+\:} 1 { target { no-opts "-O0"   no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-2.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-2.c
index ab6c1b1..4acf12c 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-2.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-2.c
@@ -29,4 +29,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"   no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]\s+\.L[0-9]\:} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-3.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-3.c
index eb1afa5..2dda690 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-3.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-3.c
@@ -29,4 +29,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"   no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+\.L[0-9]\:} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-4.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-4.c
index 535f326..9e57b0d 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-4.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-4.c
@@ -29,4 +29,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"   no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]\s+\.L[0-9]\:} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-5.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-5.c
index ea7f4e3..ae342cff 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-5.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-5.c
@@ -29,4 +29,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"   no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9]\:} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-6.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-6.c
index f340b44..6a5a9cc 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-6.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-6.c
@@ -29,4 +29,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"   no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9]\:} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-7.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-7.c
index 70aea4e..76cbfec 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-7.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-7.c
@@ -29,4 +29,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf4,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"   no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+\.L[0-9]\:} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-8.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-8.c
index 697d5fa..0f48bdb 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-8.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-8.c
@@ -29,4 +29,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf4,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0" no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf4,\s*t[au],\s*m[au]\s+\.L[0-9]\:} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-9.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-9.c
index f1edf8f..712a3ee 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-9.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_miss_default-9.c
@@ -29,4 +29,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf2,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"   no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9]\:} 1 { target { no-opts "-O0"    no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
+
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-1.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-1.c
index cd58e53..be24067 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-1.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-1.c
@@ -34,4 +34,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
-/* { dg-final { scan-assembler-times {ble\tra|[sgtf]p|t[0-6]|s[0-9]|s10|s11|a[0-7],zero,\.L[0-9]+\s*\.L[0-9]+\:\s*vle8\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
+/* { dg-final { scan-assembler-times {ble\t[a-x0-9]+,zero,\.L[0-9]+\s*\.L[0-9]+\:\s*vle8\.v\s+v[0-9]+,0\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-10.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-10.c
index 1aaebdf..81746e3 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-10.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-10.c
@@ -34,4 +34,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf2,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
-/* { dg-final { scan-assembler-times {ble\tra|[sgtf]p|t[0-6]|s[0-9]|s10|s11|a[0-7],zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle16\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
+/* { dg-final { scan-assembler-times {ble\t[a-x0-9]+,zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle16\.v\s+v[0-9]+,0\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-11.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-11.c
index 813ea49..e29afbc 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-11.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-11.c
@@ -34,4 +34,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
-/* { dg-final { scan-assembler-times {ble\tra|[sgtf]p|t[0-6]|s[0-9]|s10|s11|a[0-7],zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle32\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
+/* { dg-final { scan-assembler-times {ble\t[a-x0-9]+,zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle32\.v\s+v[0-9]+,0\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-12.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-12.c
index 9b59df9..645ee6f 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-12.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-12.c
@@ -34,4 +34,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
-/* { dg-final { scan-assembler-times {ble\tra|[sgtf]p|t[0-6]|s[0-9]|s10|s11|a[0-7],zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle32\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
+/* { dg-final { scan-assembler-times {ble\t[a-x0-9]+,zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle32\.v\s+v[0-9]+,0\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-13.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-13.c
index 35e4fd1..c399bc2 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-13.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-13.c
@@ -34,4 +34,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
-/* { dg-final { scan-assembler-times {ble\tra|[sgtf]p|t[0-6]|s[0-9]|s10|s11|a[0-7],zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle32\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
+/* { dg-final { scan-assembler-times {ble\t[a-x0-9]+,zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle32\.v\s+v[0-9]+,0\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-14.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-14.c
index 2330d34..2597531 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-14.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-14.c
@@ -214,4 +214,4 @@ void f7 (void * restrict in, void * restrict out, int n, int cond)
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m2,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m4,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m8,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
-/* { dg-final { scan-assembler-times {ble\tra|[sgtf]p|t[0-6]|s[0-9]|s10|s11|a[0-7],zero,.L[0-9]+\s+\.L[0-9]+\:\s+vlm\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 7 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
+/* { dg-final { scan-assembler-times {ble\t[a-x0-9]+,zero,.L[0-9]+\s+\.L[0-9]+\:\s+vlm\.v\s+v[0-9]+,0\([a-x0-9]+\)} 7 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-15.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-15.c
index 687ecdf..aaf5c4b 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-15.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-15.c
@@ -37,4 +37,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
-/* { dg-final { scan-assembler-times {ble\tra|[sgtf]p|t[0-6]|s[0-9]|s10|s11|a[0-7],zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle8\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
+/* { dg-final { scan-assembler-times {ble\t[a-x0-9]+,zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle8\.v\s+v[0-9]+,0\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-16.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-16.c
index d644fb6..c2e9712 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-16.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-16.c
@@ -37,4 +37,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
-/* { dg-final { scan-assembler-times {ble\tra|[sgtf]p|t[0-6]|s[0-9]|s10|s11|a[0-7],zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle8\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
+/* { dg-final { scan-assembler-times {ble\t[a-x0-9]+,zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle8\.v\s+v[0-9]+,0\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-17.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-17.c
index ea4d955..580123a 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-17.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-17.c
@@ -37,4 +37,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
-/* { dg-final { scan-assembler-times {ble\tra|[sgtf]p|t[0-6]|s[0-9]|s10|s11|a[0-7],zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle8\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
+/* { dg-final { scan-assembler-times {ble\t[a-x0-9]+,zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle8\.v\s+v[0-9]+,0\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-18.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-18.c
index cbbffb7..2154a51 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-18.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-18.c
@@ -37,4 +37,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
-/* { dg-final { scan-assembler-times {ble\tra|[sgtf]p|t[0-6]|s[0-9]|s10|s11|a[0-7],zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle8\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
+/* { dg-final { scan-assembler-times {ble\t[a-x0-9]+,zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle8\.v\s+v[0-9]+,0\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-19.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-19.c
index 21d5cc9..c707b79 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-19.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-19.c
@@ -37,4 +37,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"   } } } } */
-/* { dg-final { scan-assembler-times {ble\tra|[sgtf]p|t[0-6]|s[0-9]|s10|s11|a[0-7],zero,.L[0-9]+\s+\.L[0-9]+\:\s+vle8\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"   } } } } */
+/* { dg-final { scan-assembler-times {ble\t[a-x0-9]+,zero,.L[0-9]+\s+\.L[0-9]+\:\s+vle8\.v\s+v[0-9]+,0\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"   } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-2.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-2.c
index 39d523b..d8f2ec0 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-2.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-2.c
@@ -34,4 +34,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g"  no-opts "-flto" } } } } */
-/* { dg-final { scan-assembler-times {ble\tra|[sgtf]p|t[0-6]|s[0-9]|s10|s11|a[0-7],zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle8\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
+/* { dg-final { scan-assembler-times {ble\t[a-x0-9]+,zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle8\.v\s+v[0-9]+,0\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-20.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-20.c
index 29dd2d6..ab2e5bb 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-20.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-20.c
@@ -37,4 +37,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
-/* { dg-final { scan-assembler-times {ble\tra|[sgtf]p|t[0-6]|s[0-9]|s10|s11|a[0-7],zero,.L[0-9]+\s+\.L[0-9]+\:\s+vle8\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
+/* { dg-final { scan-assembler-times {ble\t[a-x0-9]+,zero,.L[0-9]+\s+\.L[0-9]+\:\s+vle8\.v\s+v[0-9]+,0\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-21.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-21.c
index 286a743..2ac518c 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-21.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-21.c
@@ -37,4 +37,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf4,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
-/* { dg-final { scan-assembler-times {ble\tra|[sgtf]p|t[0-6]|s[0-9]|s10|s11|a[0-7],zero,.L[0-9]+\s+\.L[0-9]+\:\s+vle16\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
+/* { dg-final { scan-assembler-times {ble\t[a-x0-9]+,zero,.L[0-9]+\s+\.L[0-9]+\:\s+vle16\.v\s+v[0-9]+,0\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-22.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-22.c
index 4cd8a5d..337fb03 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-22.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-22.c
@@ -37,4 +37,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf4,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
-/* { dg-final { scan-assembler-times {ble\tra|[sgtf]p|t[0-6]|s[0-9]|s10|s11|a[0-7],zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle16\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
+/* { dg-final { scan-assembler-times {ble\t[a-x0-9]+,zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle16\.v\s+v[0-9]+,0\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-23.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-23.c
index 5825f12..1e11dc8 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-23.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-23.c
@@ -37,4 +37,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf2,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
-/* { dg-final { scan-assembler-times {ble\tra|[sgtf]p|t[0-6]|s[0-9]|s10|s11|a[0-7],zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle16\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
+/* { dg-final { scan-assembler-times {ble\t[a-x0-9]+,zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle16\.v\s+v[0-9]+,0\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-24.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-24.c
index e2b5331..f3a8a48 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-24.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-24.c
@@ -37,4 +37,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf2,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
-/* { dg-final { scan-assembler-times {ble\tra|[sgtf]p|t[0-6]|s[0-9]|s10|s11|a[0-7],zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle16\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
+/* { dg-final { scan-assembler-times {ble\t[a-x0-9]+,zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle16\.v\s+v[0-9]+,0\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-25.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-25.c
index f40ff57..dff0bf3 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-25.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-25.c
@@ -37,4 +37,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
-/* { dg-final { scan-assembler-times {ble\tra|[sgtf]p|t[0-6]|s[0-9]|s10|s11|a[0-7],zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle32\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
+/* { dg-final { scan-assembler-times {ble\t[a-x0-9]+,zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle32\.v\s+v[0-9]+,0\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-26.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-26.c
index 26a9933..37f053b 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-26.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-26.c
@@ -37,4 +37,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
-/* { dg-final { scan-assembler-times {ble\tra|[sgtf]p|t[0-6]|s[0-9]|s10|s11|a[0-7],zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle32\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
+/* { dg-final { scan-assembler-times {ble\t[a-x0-9]+,zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle32\.v\s+v[0-9]+,0\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-27.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-27.c
index 7028d91..4b1dab6 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-27.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-27.c
@@ -37,4 +37,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
-/* { dg-final { scan-assembler-times {ble\tra|[sgtf]p|t[0-6]|s[0-9]|s10|s11|a[0-7],zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle32\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
+/* { dg-final { scan-assembler-times {ble\t[a-x0-9]+,zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle32\.v\s+v[0-9]+,0\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-28.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-28.c
index aa4c1a7..9df2609 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-28.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-28.c
@@ -234,4 +234,4 @@ void f7 (void * restrict in, void * restrict out, int n, int cond)
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m2,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m4,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m8,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
-/* { dg-final { scan-assembler-times {ble\tra|[sgtf]p|t[0-6]|s[0-9]|s10|s11|a[0-7],zero,.L[0-9]+\s*\.L[0-9]+\:\s*vlm\.v\s*(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 7 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
+/* { dg-final { scan-assembler-times {ble\t[a-x0-9]+,zero,.L[0-9]+\s*\.L[0-9]+\:\s*vlm\.v\s*v[0-9]+,0\([a-x0-9]+\)} 7 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto"  } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-3.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-3.c
index 41585d0..01ebc55 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-3.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-3.c
@@ -34,4 +34,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g"   no-opts "-flto" } } } } */
-/* { dg-final { scan-assembler-times {ble\tra|[sgtf]p|t[0-6]|s[0-9]|s10|s11|a[0-7],zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle8\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g"   no-opts "-flto" } } } } */
+/* { dg-final { scan-assembler-times {ble\t[a-x0-9]+,zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle8\.v\s+v[0-9]+,0\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g"   no-opts "-flto" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-4.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-4.c
index d4890e3..3b315aa 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-4.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-4.c
@@ -34,4 +34,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf4,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g"  no-opts "-flto"  } } } } */
-/* { dg-final { scan-assembler-times {ble\tra|[sgtf]p|t[0-6]|s[0-9]|s10|s11|a[0-7],zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle8\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g"  no-opts "-flto"  } } } } */
+/* { dg-final { scan-assembler-times {ble\t[a-x0-9]+,zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle8\.v\s+v[0-9]+,0\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g"  no-opts "-flto"  } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-5.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-5.c
index 53905fc..021054e 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-5.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-5.c
@@ -34,4 +34,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
-/* { dg-final { scan-assembler-times {ble\tra|[sgtf]p|t[0-6]|s[0-9]|s10|s11|a[0-7],zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle8\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
+/* { dg-final { scan-assembler-times {ble\t[a-x0-9]+,zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle8\.v\s+v[0-9]+,0\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-6.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-6.c
index 4d56ec5..158c50a 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-6.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-6.c
@@ -34,4 +34,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
-/* { dg-final { scan-assembler-times {ble\tra|[sgtf]p|t[0-6]|s[0-9]|s10|s11|a[0-7],zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle8\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
+/* { dg-final { scan-assembler-times {ble\t[a-x0-9]+,zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle8\.v\s+v[0-9]+,0\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-7.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-7.c
index f722ec4..1191106 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-7.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-7.c
@@ -34,4 +34,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf4,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
-/* { dg-final { scan-assembler-times {ble\tra|[sgtf]p|t[0-6]|s[0-9]|s10|s11|a[0-7],zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle16\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
+/* { dg-final { scan-assembler-times {ble\t[a-x0-9]+,zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle16\.v\s+v[0-9]+,0\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-8.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-8.c
index 69bd0be..6239bdf 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-8.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-8.c
@@ -34,4 +34,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf4,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
-/* { dg-final { scan-assembler-times {ble\tra|[sgtf]p|t[0-6]|s[0-9]|s10|s11|a[0-7],zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle16\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
+/* { dg-final { scan-assembler-times {ble\t[a-x0-9]+,zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle16\.v\s+v[0-9]+,0\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-9.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-9.c
index 208173f..d276b8a 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-9.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_phi-9.c
@@ -34,4 +34,4 @@ void f (void * restrict in, void * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf2,\s*t[au],\s*m[au]} 4 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
-/* { dg-final { scan-assembler-times {ble\tra|[sgtf]p|t[0-6]|s[0-9]|s10|s11|a[0-7],zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle16\.v\s+(?:v[0-9]|v[1-2][0-9]|v3[0-1]),0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
+/* { dg-final { scan-assembler-times {ble\t[a-x0-9]+,zero,.L[0-9]+\s*\.L[0-9]+\:\s*vle16\.v\s+v[0-9]+,0\([a-x0-9]+\)} 1 { target { no-opts "-O0"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_switch_vtype-10.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_switch_vtype-10.c
index b68932a..cdbe856 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_switch_vtype-10.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_switch_vtype-10.c
@@ -42,6 +42,5 @@ void foo (int8_t * restrict in, int8_t * restrict out, int n, int cond)
 }
 
 /* { dg-final { scan-assembler-times {vsetvli} 9 { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
-/* { dg-final { scan-assembler-times {\s*\.L[0-9]+:\s*vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+\.L[0-9]+} 1 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]} 3 { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
 /* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*mf2,\s*t[au],\s*m[au]} 2 { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_switch_vtype-12.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_switch_vtype-12.c
index eaf6992..66c36ab 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_switch_vtype-12.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vlmax_switch_vtype-12.c
@@ -52,4 +52,4 @@ void foo (int8_t * restrict in, int8_t * restrict out, int n, int cond1, int con
     }
 }
 /* { dg-final { scan-assembler-times {vsetvli} 9 { target { no-opts "-O0" no-opts "-O1" no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" } } } } */
-/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*mf2,\s*t[au],\s*m[au]\s+j\s+\.L[0-9]+} 1 { target { no-opts "-O0" no-opts "-O1"  no-opts "-Os" no-opts "-funroll-loops" no-opts "-g" no-opts "-flto" } } } } */
+
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-1.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-1.c
new file mode 100644
index 0000000..b82e249
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-1.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f(int8_t *base, int8_t *out, size_t vl, size_t m, vbool64_t mask) {
+  size_t avl = __riscv_vsetvl_e8mf8(vl);
+
+  for (size_t i = 0; i < m; i++) {
+    vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i, avl);
+    __riscv_vse8_v_i8mf8(out + i, v0, avl);
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-10.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-10.c
new file mode 100644
index 0000000..3c7e0ec
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-10.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void foo(void *in1, void *in2, void *in3, void *out, size_t n, size_t vl) {
+  for (size_t i = 0; i < n; i += 1) {
+    vint32m1_t a = __riscv_vle32_v_i32m1(in1, __riscv_vsetvl_e16m1(vl));
+    vint32m1_t b = __riscv_vle32_v_i32m1_tu(a, in2, __riscv_vsetvl_e16m1(vl));
+    vint32m1_t c = __riscv_vle32_v_i32m1_tu(b, in3, __riscv_vsetvl_e16m1(vl));
+    __riscv_vse32_v_i32m1(out, c, __riscv_vsetvl_e16m1(vl));
+    
+    vint8mf2_t a2 = __riscv_vle8_v_i8mf2(in1 + 100, __riscv_vsetvl_e8m1(vl));
+    vint8mf2_t b2 = __riscv_vle8_v_i8mf2_tu(a2, in2 + 100, __riscv_vsetvl_e8m1(vl));
+    vint8mf2_t c2 = __riscv_vle8_v_i8mf2_tu(b2, in3 + 100, __riscv_vsetvl_e8m1(vl));
+    __riscv_vse8_v_i8mf2(out + 100, c2, __riscv_vsetvl_e8m1(vl));
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli} 4 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-11.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-11.c
new file mode 100644
index 0000000..fa825f0
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-11.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void foo(int32_t *in1, int32_t *in2, int32_t *in3, int32_t *out, size_t n, int cond, int avl) {
+  
+  size_t vl;
+  if (cond)
+    vl = __riscv_vsetvl_e32m1(avl);
+  else
+    vl = __riscv_vsetvl_e16mf2(avl);
+  for (size_t i = 0; i < n; i += 1) {
+    vint32m1_t a = __riscv_vle32_v_i32m1(in1, vl);
+    vint32m1_t b = __riscv_vle32_v_i32m1_tu(a, in2, vl);
+    vint32m1_t c = __riscv_vle32_v_i32m1_tu(b, in3, vl);
+    __riscv_vse32_v_i32m1(out, c, vl);
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli} 3 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-12.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-12.c
new file mode 100644
index 0000000..fc7e1cb
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-12.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void foo(int32_t *in1, int32_t *in2, int32_t *in3, int32_t *out, size_t n, int cond, int avl) {
+  
+  size_t vl;
+  if (cond)
+    vl = __riscv_vsetvl_e32m1(avl);
+  else
+    vl = 3;
+  for (size_t i = 0; i < n; i += 1) {
+    vint32m1_t a = __riscv_vle32_v_i32m1(in1, vl);
+    vint32m1_t b = __riscv_vle32_v_i32m1_tu(a, in2, vl);
+    vint32m1_t c = __riscv_vle32_v_i32m1_tu(b, in3, vl);
+    __riscv_vse32_v_i32m1(out, c, vl);
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-13.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-13.c
new file mode 100644
index 0000000..6157a2c
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-13.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void foo(int32_t *in1, int32_t *in2, int32_t *in3, int32_t *out, size_t n, int cond, int avl) {
+  
+  size_t vl;
+  if (cond)
+    vl = __riscv_vsetvl_e32m1(avl);
+  else
+    vl = 55;
+  for (size_t i = 0; i < n; i += 1) {
+    vint32m1_t a = __riscv_vle32_v_i32m1(in1, vl);
+    vint32m1_t b = __riscv_vle32_v_i32m1_tu(a, in2, vl);
+    vint32m1_t c = __riscv_vle32_v_i32m1_tu(b, in3, vl);
+    __riscv_vse32_v_i32m1(out, c, vl);
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-14.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-14.c
new file mode 100644
index 0000000..40d4af00
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-14.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void foo(int32_t *in1, int32_t *in2, int32_t *in3, int32_t *out, size_t n, int cond, int avl) {
+  
+  size_t vl;
+  if (cond){
+    vl = __riscv_vsetvl_e32m1(avl);
+    vint16mf2_t v = *(vint16mf2_t*)(in1 + 1000);
+    *(vint16mf2_t*)(out + 1000) = v;
+  }
+  else
+    vl = 55;
+  for (size_t i = 0; i < n; i += 1) {
+    vint32m1_t a = __riscv_vle32_v_i32m1(in1, vl);
+    vint32m1_t b = __riscv_vle32_v_i32m1_tu(a, in2, vl);
+    vint32m1_t c = __riscv_vle32_v_i32m1_tu(b, in3, vl);
+    __riscv_vse32_v_i32m1(out, c, vl);
+  }
+}
+
+/* { dg-final { scan-assembler {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]} { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-15.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-15.c
new file mode 100644
index 0000000..c677a81
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-15.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void foo(int32_t *in1, int32_t *in2, int32_t *in3, int32_t *out, size_t n, int cond, int avl) {
+  
+  size_t vl;
+  if (cond)
+    vl = __riscv_vsetvl_e32m1(avl);
+  else
+    vl = __riscv_vsetvl_e16mf2(avl) >> 4;
+  for (size_t i = 0; i < n; i += 1) {
+    vint32m1_t a = __riscv_vle32_v_i32m1(in1, vl);
+    vint32m1_t b = __riscv_vle32_v_i32m1_tu(a, in2, vl);
+    vint32m1_t c = __riscv_vle32_v_i32m1_tu(b, in3, vl);
+    __riscv_vse32_v_i32m1(out, c, vl);
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli} 3 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {srli\s+[a-x0-9]+,\s*[a-x0-9]+,\s*4} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-16.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-16.c
new file mode 100644
index 0000000..37a9039
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-16.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f(int8_t *base, int8_t *out, size_t vl, size_t m) {
+  size_t avl;
+  if (m > 100)
+    avl = __riscv_vsetvl_e8mf8(vl << 10);
+  else
+    avl = __riscv_vsetvl_e8mf8(vl);
+
+  for (size_t i = 0; i < m; i++) {
+    vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i, avl);
+    __riscv_vse8_v_i8mf8(out + i, v0, avl);
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli} 3 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {slli\s+[a-x0-9]+,\s*[a-x0-9]+,\s*10} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-17.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-17.c
new file mode 100644
index 0000000..ee58f9b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-17.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void foo(int32_t *in1, int32_t *in2, int32_t *in3, int32_t *out, size_t n, int cond, int vl) {
+  
+  vint32m1_t a = __riscv_vle32_v_i32m1(in1, __riscv_vsetvl_e8mf8 (vl));
+  vint32m1_t b = __riscv_vle32_v_i32m1_tu(a, in2, __riscv_vsetvl_e8mf4 (vl));
+  vint32m1_t c = __riscv_vle32_v_i32m1_tu(b, in3, __riscv_vsetvl_e8m1 (vl));
+  __riscv_vse32_v_i32m1(out, c, __riscv_vsetvl_e8mf2 (vl));
+}
+
+/* { dg-final { scan-assembler-times {vsetvli} 8 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-18.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-18.c
new file mode 100644
index 0000000..7ad277e
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-18.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f(int8_t *base, int8_t *out, size_t vl, size_t m, size_t n) {
+  vint8mf4_t v1 = *(vint8mf4_t*) (base + 100000);
+  size_t avl = __riscv_vsetvl_e8mf8(vl);
+  for (size_t i = 0; i < m; i++) {
+    vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i, avl);
+    if (n > 100) {
+      __riscv_vse8_v_i8mf4(out + i, v1, avl);
+    } else {
+      __riscv_vse8_v_i8mf8(out + i, v0, avl);
+    }
+  }
+}
+
+/* { dg-final { scan-assembler {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf8,\s*t[au],\s*m[au]} { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf4,\s*t[au],\s*m[au]} { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-19.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-19.c
new file mode 100644
index 0000000..87ef3ac
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-19.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f(int32_t *in1, int32_t *in2, int32_t *in3, int32_t *out, size_t n, int cond, int avl) {
+  
+  size_t vl;
+  if (cond)
+    vl = __riscv_vsetvl_e32m1(avl);
+  else
+    vl = __riscv_vsetvl_e32m1(avl) << 5;
+  for (size_t i = 0; i < n; i += 1) {
+    vint32m1_t a = __riscv_vle32_v_i32m1(in1, vl);
+    vint32m1_t b = __riscv_vle32_v_i32m1_tu(a, in2, vl);
+    vint32m1_t c = __riscv_vle32_v_i32m1_tu(b, in3, vl);
+    __riscv_vse32_v_i32m1(out, c, vl);
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-O1" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {slli\s+[a-x0-9]+,\s*[a-x0-9]+,\s*5} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-2.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-2.c
new file mode 100644
index 0000000..fb8f14e
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-2.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f(int8_t *base, int8_t *out, size_t vl, size_t m) {
+  size_t avl;
+  if (m > 100)
+    avl = __riscv_vsetvl_e8mf8(vl << 10);
+  else
+    avl = __riscv_vsetvl_e8mf8(vl);
+
+  for (size_t i = 0; i < m; i++) {
+    vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i, avl);
+    __riscv_vse8_v_i8mf8(out + i, v0, avl);
+  }
+}
+
+/* { dg-final { scan-assembler-times {slli\s+[a-x0-9]+,\s*[a-x0-9]+,\s*10} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 3 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-20.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-20.c
new file mode 100644
index 0000000..d3f4a27
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-20.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f(int32_t *in1, int32_t *in2, int32_t *in3, int32_t *out, size_t n, int cond, int avl) {
+  
+  size_t vl;
+  if (cond)
+    vl = __riscv_vsetvl_e32m1(avl);
+  else
+    vl = (__riscv_vsetvl_e32m1(avl) << 5) + 100;
+  for (size_t i = 0; i < n; i += 1) {
+    vint32m1_t a = __riscv_vle32_v_i32m1(in1, vl);
+    vint32m1_t b = __riscv_vle32_v_i32m1_tu(a, in2, vl);
+    vint32m1_t c = __riscv_vle32_v_i32m1_tu(b, in3, vl);
+    __riscv_vse32_v_i32m1(out, c, vl);
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-O1" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {slli\s+[a-x0-9]+,\s*[a-x0-9]+,\s*5} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {addi\s+[a-x0-9]+,\s*[a-x0-9]+,\s*100} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-3.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-3.c
new file mode 100644
index 0000000..98306cc
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-3.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f(int8_t *base, int8_t *out, size_t vl, size_t m) {
+  size_t avl;
+  if (m > 100)
+    avl = __riscv_vsetvl_e8mf8(vl << 10);
+  else
+    avl = __riscv_vsetvl_e8mf8(vl);
+
+  for (size_t i = 0; i < m; i++) {
+    vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i, avl);
+    v0 = __riscv_vle8_v_i8mf8_tu(v0,base + i, avl);
+    __riscv_vse8_v_i8mf8(out + i, v0, avl);
+  }
+}
+
+/* { dg-final { scan-assembler-times {slli\s+[a-x0-9]+,\s*[a-x0-9]+,\s*10} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 3 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-4.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-4.c
new file mode 100644
index 0000000..548958c
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-4.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f(int8_t *base, int8_t *out, size_t vl, size_t m) {
+  size_t avl;
+  if (m > 100)
+    avl = __riscv_vsetvl_e8mf8(vl << 10);
+  else
+    avl = vl;
+
+  for (size_t i = 0; i < m; i++) {
+    vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i, avl);
+    v0 = __riscv_vle8_v_i8mf8_tu(v0,base + i, avl);
+    __riscv_vse8_v_i8mf8(out + i, v0, avl);
+  }
+}
+
+/* { dg-final { scan-assembler-times {slli\s+[a-x0-9]+,\s*[a-x0-9]+,\s*10} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-5.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-5.c
new file mode 100644
index 0000000..35ffe7e
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-5.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void foo(int32_t *in1, int32_t *in2, int32_t *in3, int32_t *out, size_t n, size_t vl) {
+  for (size_t i = 0; i < n; i += 1) {
+    vint32m1_t a = __riscv_vle32_v_i32m1(in1, __riscv_vsetvl_e32m1(vl));
+    vint32m1_t b = __riscv_vle32_v_i32m1_tu(a, in2, __riscv_vsetvl_e32m1(vl));
+    vint32m1_t c = __riscv_vle32_v_i32m1_tu(b, in3, __riscv_vsetvl_e32m1(vl));
+    __riscv_vse32_v_i32m1(out, c, __riscv_vsetvl_e32m1(vl));
+  }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle32\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-6.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-6.c
new file mode 100644
index 0000000..180ef07
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-6.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void foo(int32_t *in1, int32_t *in2, int32_t *in3, int32_t *out, size_t n, size_t vl) {
+  for (size_t i = 0; i < n; i += 1) {
+    vint32m1_t a = __riscv_vle32_v_i32m1(in1, __riscv_vsetvl_e32m1(vl));
+    __riscv_vse32_v_i32m1(out, a, __riscv_vsetvl_e32m1(vl));
+  }
+  
+  for (size_t i = 0; i < n; i += 1) {
+    vint32m1_t a = __riscv_vle32_v_i32m1(in1 + 100, __riscv_vsetvl_e32m1(vl));
+    vint32m1_t b = __riscv_vle32_v_i32m1_tu(a, in2 + 100, __riscv_vsetvl_e32m1(vl));
+    vint32m1_t c = __riscv_vle32_v_i32m1_tu(b, in3 + 100, __riscv_vsetvl_e32m1(vl));
+    __riscv_vse32_v_i32m1(out + 100, c, __riscv_vsetvl_e32m1(vl));
+  }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle32\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 2 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-7.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-7.c
new file mode 100644
index 0000000..84d948b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-7.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void foo(int32_t *in1, int32_t *in2, int32_t *in3, int32_t *out, size_t n, size_t vl) {
+  for (size_t i = 0; i < n; i += 1) {
+    vint32m1_t a = __riscv_vle32_v_i32m1(in1, __riscv_vsetvl_e16mf2(vl));
+    vint32m1_t b = __riscv_vle32_v_i32m1_tu(a, in2, __riscv_vsetvl_e16mf2(vl));
+    vint32m1_t c = __riscv_vle32_v_i32m1_tu(b, in3, __riscv_vsetvl_e16mf2(vl));
+    __riscv_vse32_v_i32m1(out, c, __riscv_vsetvl_e16mf2(vl));
+  }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle32\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-8.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-8.c
new file mode 100644
index 0000000..6f4c792
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-8.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void foo(int32_t *in1, int32_t *in2, int32_t *in3, int32_t *out, size_t n, size_t vl) {
+  for (size_t i = 0; i < n; i += 1) {
+    vint32m1_t a = __riscv_vle32_v_i32m1(in1, __riscv_vsetvl_e16mf2(vl));
+    __riscv_vse32_v_i32m1(out, a, __riscv_vsetvl_e16mf2(vl));
+  }
+  
+  for (size_t i = 0; i < n; i += 1) {
+    vint32m1_t a = __riscv_vle32_v_i32m1(in1 + 100, __riscv_vsetvl_e16mf2(vl));
+    vint32m1_t b = __riscv_vle32_v_i32m1_tu(a, in2 + 100, __riscv_vsetvl_e16mf2(vl));
+    vint32m1_t c = __riscv_vle32_v_i32m1_tu(b, in3 + 100, __riscv_vsetvl_e16mf2(vl));
+    __riscv_vse32_v_i32m1(out + 100, c, __riscv_vsetvl_e16mf2(vl));
+  }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle32\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 2 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-9.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-9.c
new file mode 100644
index 0000000..d07152c
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvl-9.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void foo(void *in1, void *in2, void *in3, void *out, size_t n, size_t vl) {
+  for (size_t i = 0; i < n; i += 1) {
+    vint32m1_t a = __riscv_vle32_v_i32m1(in1, __riscv_vsetvl_e16mf2(vl));
+    vint32m1_t b = __riscv_vle32_v_i32m1_tu(a, in2, __riscv_vsetvl_e16mf2(vl));
+    vint32m1_t c = __riscv_vle32_v_i32m1_tu(b, in3, __riscv_vsetvl_e16mf2(vl));
+    __riscv_vse32_v_i32m1(out, c, __riscv_vsetvl_e16mf2(vl));
+    
+    vint8mf4_t a2 = __riscv_vle8_v_i8mf4(in1 + 100, __riscv_vsetvl_e32m1(vl));
+    vint8mf4_t b2 = __riscv_vle8_v_i8mf4_tu(a2, in2 + 100, __riscv_vsetvl_e32m1(vl));
+    vint8mf4_t c2 = __riscv_vle8_v_i8mf4_tu(b2, in3 + 100, __riscv_vsetvl_e32m1(vl));
+    __riscv_vse8_v_i8mf4(out + 100, c2, __riscv_vsetvl_e32m1(vl));
+  }
+}
+
+/* { dg-final { scan-assembler {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]} { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-1.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-1.c
new file mode 100644
index 0000000..49e0a53
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-1.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void foo(int32_t *in1, int32_t *in2, int32_t *in3, int32_t *out, size_t n) {
+  for (size_t i = 0; i < n; i += 1) {
+    vint32m1_t a = __riscv_vle32_v_i32m1(in1, __riscv_vsetvlmax_e32m1());
+    vint32m1_t b = __riscv_vle32_v_i32m1_tu(a, in2, __riscv_vsetvlmax_e32m1());
+    vint32m1_t c = __riscv_vle32_v_i32m1_tu(b, in3, __riscv_vsetvlmax_e32m1());
+    __riscv_vse32_v_i32m1(out, c, __riscv_vsetvlmax_e32m1());
+  }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle32\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*m1,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-10.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-10.c
new file mode 100644
index 0000000..5b5a31b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-10.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void foo(int32_t *in1, int32_t *in2, int32_t *in3, int32_t *out, size_t n, int cond) {
+  
+  size_t vl;
+  if (cond)
+    vl = __riscv_vsetvlmax_e32m1();
+  else
+    vl = 3;
+  for (size_t i = 0; i < n; i += 1) {
+    vint32m1_t a = __riscv_vle32_v_i32m1(in1, vl);
+    vint32m1_t b = __riscv_vle32_v_i32m1_tu(a, in2, vl);
+    vint32m1_t c = __riscv_vle32_v_i32m1_tu(b, in3, vl);
+    __riscv_vse32_v_i32m1(out, c, vl);
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*m1,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-11.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-11.c
new file mode 100644
index 0000000..e880c2c
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-11.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void foo(int32_t *in1, int32_t *in2, int32_t *in3, int32_t *out, size_t n, int cond) {
+  
+  size_t vl;
+  if (cond)
+    vl = __riscv_vsetvlmax_e32m1();
+  else
+    vl = 55;
+  for (size_t i = 0; i < n; i += 1) {
+    vint32m1_t a = __riscv_vle32_v_i32m1(in1, vl);
+    vint32m1_t b = __riscv_vle32_v_i32m1_tu(a, in2, vl);
+    vint32m1_t c = __riscv_vle32_v_i32m1_tu(b, in3, vl);
+    __riscv_vse32_v_i32m1(out, c, vl);
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*m1,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-12.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-12.c
new file mode 100644
index 0000000..c141f8b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-12.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void foo(int32_t *in1, int32_t *in2, int32_t *in3, int32_t *out, size_t n, int cond) {
+  
+  size_t vl;
+  if (cond) {
+    vl = __riscv_vsetvlmax_e32m1();
+    vint16mf2_t v = *(vint16mf2_t*)(in1 + 1000);
+    *(vint16mf2_t*)(out + 1000) = v;
+  }
+  else
+    vl = 55;
+  for (size_t i = 0; i < n; i += 1) {
+    vint32m1_t a = __riscv_vle32_v_i32m1(in1, vl);
+    vint32m1_t b = __riscv_vle32_v_i32m1_tu(a, in2, vl);
+    vint32m1_t c = __riscv_vle32_v_i32m1_tu(b, in3, vl);
+    __riscv_vse32_v_i32m1(out, c, vl);
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*m1,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-13.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-13.c
new file mode 100644
index 0000000..1b92cb8
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-13.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void foo(int32_t *in1, int32_t *in2, int32_t *in3, int32_t *out, size_t n, int cond) {
+  
+  size_t vl;
+  if (cond) {
+    vl = __riscv_vsetvlmax_e32m1();
+    vint8mf8_t v = *(vint8mf8_t*)(in1 + 1000);
+    *(vint8mf8_t*)(out + 1000) = v;
+  }
+  else
+    vl = 55;
+  for (size_t i = 0; i < n; i += 1) {
+    vint32m1_t a = __riscv_vle32_v_i32m1(in1, vl);
+    vint32m1_t b = __riscv_vle32_v_i32m1_tu(a, in2, vl);
+    vint32m1_t c = __riscv_vle32_v_i32m1_tu(b, in3, vl);
+    __riscv_vse32_v_i32m1(out, c, vl);
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*m1,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 3 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-14.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-14.c
new file mode 100644
index 0000000..170172d
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-14.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f(int8_t *base, int8_t *out, size_t vl, size_t m) {
+  size_t avl = __riscv_vsetvlmax_e8mf8();
+
+  for (size_t i = 0; i < m; i++) {
+    vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i, avl);
+    v0 = __riscv_vle8_v_i8mf8_tu(v0, base + i + 100, avl);
+    __riscv_vse8_v_i8mf8(out + i, v0, avl);
+  }
+}
+
+/* { dg-final { scan-assembler-times {\.L[0-9]+\:\s+vle8\.v\s+v[0-9]+,\s*0\s*\([a-x0-9]+\)} 1 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf8,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-15.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-15.c
new file mode 100644
index 0000000..12151bc
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-15.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void foo(int32_t *in1, int32_t *in2, int32_t *in3, int32_t *out, size_t n, int cond) {
+  
+  size_t vl;
+  if (cond)
+    vl = __riscv_vsetvlmax_e32m1();
+  else
+    vl = __riscv_vsetvlmax_e16mf2() << 5;
+  for (size_t i = 0; i < n; i += 1) {
+    vint32m1_t a = __riscv_vle32_v_i32m1(in1, vl);
+    vint32m1_t b = __riscv_vle32_v_i32m1_tu(a, in2, vl);
+    vint32m1_t c = __riscv_vle32_v_i32m1_tu(b, in3, vl);
+    __riscv_vse32_v_i32m1(out, c, vl);
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*m1,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 3 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {slli\s+[a-x0-9]+,\s*[a-x0-9]+,\s*5} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-16.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-16.c
new file mode 100644
index 0000000..6cce6fe
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-16.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void foo(int32_t *in1, int32_t *in2, int32_t *in3, int32_t *out, size_t n, int cond) {
+  
+  vint32m1_t a = __riscv_vle32_v_i32m1(in1, __riscv_vsetvlmax_e8mf8 ());
+  vint32m1_t b = __riscv_vle32_v_i32m1_tu(a, in2, __riscv_vsetvlmax_e8mf4 ());
+  vint32m1_t c = __riscv_vle32_v_i32m1_tu(b, in3, __riscv_vsetvlmax_e8m1 ());
+  __riscv_vse32_v_i32m1(out, c, __riscv_vsetvlmax_e8mf2 ());
+}
+
+/* { dg-final { scan-assembler-times {vsetvli} 7 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-17.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-17.c
new file mode 100644
index 0000000..d28d6f8
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-17.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void foo(int32_t *in1, int32_t *in2, int32_t *in3, int32_t *out, size_t n, int cond) {
+  
+  for (int i = 0; i < n; i++){
+    vint32m1_t a = __riscv_vle32_v_i32m1(in1 + i, __riscv_vsetvlmax_e8mf8 ());
+    vint32m1_t b = __riscv_vle32_v_i32m1_tu(a, in2 + i, __riscv_vsetvlmax_e8mf4 ());
+    vint32m1_t c = __riscv_vle32_v_i32m1_tu(b, in3 + i, __riscv_vsetvlmax_e8m1 ());
+    __riscv_vse32_v_i32m1(out + i, c, __riscv_vsetvlmax_e8mf2 ());
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli} 7 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-18.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-18.c
new file mode 100644
index 0000000..c1c18c3
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-18.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void f(int8_t *base, int8_t *out, size_t vl, size_t m, size_t n) {
+  vint8mf4_t v1 = *(vint8mf4_t*) (base + 100000);
+  size_t avl = __riscv_vsetvlmax_e8mf8();
+  for (size_t i = 0; i < m; i++) {
+    vint8mf8_t v0 = __riscv_vle8_v_i8mf8(base + i, avl);
+    if (n > 100) {
+      __riscv_vse8_v_i8mf4(out + i + 100, v1, avl);
+    } else {
+      __riscv_vse8_v_i8mf8(out + i, v0, avl);
+    }
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli} 4 { target { no-opts "-O0" no-opts "-Os" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-19.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-19.c
new file mode 100644
index 0000000..1d77efb
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-19.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void foo(int32_t *in1, int32_t *in2, int32_t *in3, int32_t *out, size_t n, int cond) {
+  
+  size_t vl;
+  if (cond)
+    vl = __riscv_vsetvlmax_e32m1();
+  else
+    vl = __riscv_vsetvlmax_e32m1() << 5;
+  for (size_t i = 0; i < n; i += 1) {
+    vint32m1_t a = __riscv_vle32_v_i32m1(in1, vl);
+    vint32m1_t b = __riscv_vle32_v_i32m1_tu(a, in2, vl);
+    vint32m1_t c = __riscv_vle32_v_i32m1_tu(b, in3, vl);
+    __riscv_vse32_v_i32m1(out, c, vl);
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-O1" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {slli\s+[a-x0-9]+,\s*[a-x0-9]+,\s*5} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-2.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-2.c
new file mode 100644
index 0000000..482a483
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-2.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void foo(int32_t *in1, int32_t *in2, int32_t *in3, int32_t *out, size_t n) {
+  for (size_t i = 0; i < n; i += 1) {
+    vint32m1_t a = __riscv_vle32_v_i32m1(in1, __riscv_vsetvlmax_e32m1());
+    __riscv_vse32_v_i32m1(out, a, __riscv_vsetvlmax_e32m1());
+  }
+  
+  for (size_t i = 0; i < n; i += 1) {
+    vint32m1_t a = __riscv_vle32_v_i32m1(in1 + 100, __riscv_vsetvlmax_e32m1());
+    vint32m1_t b = __riscv_vle32_v_i32m1_tu(a, in2 + 100, __riscv_vsetvlmax_e32m1());
+    vint32m1_t c = __riscv_vle32_v_i32m1_tu(b, in3 + 100, __riscv_vsetvlmax_e32m1());
+    __riscv_vse32_v_i32m1(out + 100, c, __riscv_vsetvlmax_e32m1());
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*m1,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-20.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-20.c
new file mode 100644
index 0000000..1102d7e
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-20.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void foo(int32_t *in1, int32_t *in2, int32_t *in3, int32_t *out, size_t n, int cond) {
+  
+  for (size_t i = 0; i < n; i += 1) {
+    size_t vl = __riscv_vsetvlmax_e32m1();
+    vint16mf2_t v = *(vint16mf2_t*)(in1 + 1000);
+    *(vint16mf2_t*)(out + 1000) = v;
+    vint32m1_t a = __riscv_vle32_v_i32m1(in1, vl);
+    vint32m1_t b = __riscv_vle32_v_i32m1_tu(a, in2, vl);
+    vint32m1_t c = __riscv_vle32_v_i32m1_tu(b, in3, vl);
+    __riscv_vse32_v_i32m1(out, c, vl);
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-O1" no-opts "-g" no-opts "-funroll-loops" } } } } */
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-3.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-3.c
new file mode 100644
index 0000000..cc0135f
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-3.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void foo(int32_t *in1, int32_t *in2, int32_t *in3, int32_t *out, size_t n) {
+  for (size_t i = 0; i < n; i += 1) {
+    vint32m1_t a = __riscv_vle32_v_i32m1(in1, __riscv_vsetvlmax_e16mf2());
+    vint32m1_t b = __riscv_vle32_v_i32m1_tu(a, in2, __riscv_vsetvlmax_e16mf2());
+    vint32m1_t c = __riscv_vle32_v_i32m1_tu(b, in3, __riscv_vsetvlmax_e16mf2());
+    __riscv_vse32_v_i32m1(out, c, __riscv_vsetvlmax_e16mf2());
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*m1,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-4.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-4.c
new file mode 100644
index 0000000..3b9865e
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-4.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void foo(int32_t *in1, int32_t *in2, int32_t *in3, int32_t *out, size_t n) {
+  for (size_t i = 0; i < n; i += 1) {
+    vint32m1_t a = __riscv_vle32_v_i32m1(in1, __riscv_vsetvlmax_e16mf2());
+    __riscv_vse32_v_i32m1(out, a, __riscv_vsetvlmax_e16mf2());
+  }
+  
+  for (size_t i = 0; i < n; i += 1) {
+    vint32m1_t a = __riscv_vle32_v_i32m1(in1 + 100, __riscv_vsetvlmax_e16mf2());
+    vint32m1_t b = __riscv_vle32_v_i32m1_tu(a, in2 + 100, __riscv_vsetvlmax_e16mf2());
+    vint32m1_t c = __riscv_vle32_v_i32m1_tu(b, in3 + 100, __riscv_vsetvlmax_e16mf2());
+    __riscv_vse32_v_i32m1(out + 100, c, __riscv_vsetvlmax_e16mf2());
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*m1,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-5.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-5.c
new file mode 100644
index 0000000..0a3a5a3
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-5.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void foo(void *in1, void *in2, void *in3, void *out, size_t n) {
+  for (size_t i = 0; i < n; i += 1) {
+    vint32m1_t a = __riscv_vle32_v_i32m1(in1, __riscv_vsetvlmax_e16mf2());
+    vint32m1_t b = __riscv_vle32_v_i32m1_tu(a, in2, __riscv_vsetvlmax_e16mf2());
+    vint32m1_t c = __riscv_vle32_v_i32m1_tu(b, in3, __riscv_vsetvlmax_e16mf2());
+    __riscv_vse32_v_i32m1(out, c, __riscv_vsetvlmax_e16mf2());
+    
+    vint8mf4_t a2 = __riscv_vle8_v_i8mf4(in1 + 100, __riscv_vsetvlmax_e32m1());
+    vint8mf4_t b2 = __riscv_vle8_v_i8mf4_tu(a2, in2 + 100, __riscv_vsetvlmax_e32m1());
+    vint8mf4_t c2 = __riscv_vle8_v_i8mf4_tu(b2, in3 + 100, __riscv_vsetvlmax_e32m1());
+    __riscv_vse8_v_i8mf4(out + 100, c2, __riscv_vsetvlmax_e32m1());
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*m1,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-6.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-6.c
new file mode 100644
index 0000000..c32f15d
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-6.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void foo(void *in1, void *in2, void *in3, void *out, size_t n) {
+  for (size_t i = 0; i < n; i += 1) {
+    vint32m1_t a = __riscv_vle32_v_i32m1(in1, __riscv_vsetvlmax_e16mf2());
+    vint32m1_t b = __riscv_vle32_v_i32m1_tu(a, in2, __riscv_vsetvlmax_e16mf2());
+    vint32m1_t c = __riscv_vle32_v_i32m1_tu(b, in3, __riscv_vsetvlmax_e16mf2());
+    __riscv_vse32_v_i32m1(out, c, __riscv_vsetvlmax_e16mf2());
+    
+    vint8mf2_t a2 = __riscv_vle8_v_i8mf2(in1 + 100, __riscv_vsetvlmax_e8mf2());
+    vint8mf2_t b2 = __riscv_vle8_v_i8mf2_tu(a2, in2 + 100, __riscv_vsetvlmax_e8mf2());
+    vint8mf2_t c2 = __riscv_vle8_v_i8mf2_tu(b2, in3 + 100, __riscv_vsetvlmax_e8mf2());
+    __riscv_vse8_v_i8mf2(out + 100, c2, __riscv_vsetvlmax_e8mf2());
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*m1,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*mf2,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-7.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-7.c
new file mode 100644
index 0000000..0ee04ee
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-7.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void foo(void *in1, void *in2, void *in3, void *out, size_t n) {
+  for (size_t i = 0; i < n; i += 1) {
+    vint32m1_t a = __riscv_vle32_v_i32m1(in1, __riscv_vsetvlmax_e16m1());
+    vint32m1_t b = __riscv_vle32_v_i32m1_tu(a, in2, __riscv_vsetvlmax_e16m1());
+    vint32m1_t c = __riscv_vle32_v_i32m1_tu(b, in3, __riscv_vsetvlmax_e16m1());
+    __riscv_vse32_v_i32m1(out, c, __riscv_vsetvlmax_e16m1());
+    
+    vint8mf2_t a2 = __riscv_vle8_v_i8mf2(in1 + 100, __riscv_vsetvlmax_e8m1());
+    vint8mf2_t b2 = __riscv_vle8_v_i8mf2_tu(a2, in2 + 100, __riscv_vsetvlmax_e8m1());
+    vint8mf2_t c2 = __riscv_vle8_v_i8mf2_tu(b2, in3 + 100, __riscv_vsetvlmax_e8m1());
+    __riscv_vse8_v_i8mf2(out + 100, c2, __riscv_vsetvlmax_e8m1());
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e16,\s*m1,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e8,\s*m1,\s*t[au],\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e8,\s*mf2,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 4 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-8.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-8.c
new file mode 100644
index 0000000..a0335a3
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-8.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void foo(int32_t *in1, int32_t *in2, int32_t *in3, int32_t *out, size_t n, int cond) {
+  
+  size_t vl;
+  if (cond)
+    vl = __riscv_vsetvlmax_e32m1();
+  else
+    vl = __riscv_vsetvlmax_e16mf2();
+  for (size_t i = 0; i < n; i += 1) {
+    vint32m1_t a = __riscv_vle32_v_i32m1(in1, vl);
+    vint32m1_t b = __riscv_vle32_v_i32m1_tu(a, in2, vl);
+    vint32m1_t c = __riscv_vle32_v_i32m1_tu(b, in3, vl);
+    __riscv_vse32_v_i32m1(out, c, vl);
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*m1,\s*tu,\s*m[au]} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-9.c b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-9.c
new file mode 100644
index 0000000..5b5a31b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/vsetvl/vsetvlmax-9.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv32gcv -mabi=ilp32 -fno-schedule-insns -fno-schedule-insns2" } */
+
+#include "riscv_vector.h"
+
+void foo(int32_t *in1, int32_t *in2, int32_t *in3, int32_t *out, size_t n, int cond) {
+  
+  size_t vl;
+  if (cond)
+    vl = __riscv_vsetvlmax_e32m1();
+  else
+    vl = 3;
+  for (size_t i = 0; i < n; i += 1) {
+    vint32m1_t a = __riscv_vle32_v_i32m1(in1, vl);
+    vint32m1_t b = __riscv_vle32_v_i32m1_tu(a, in2, vl);
+    vint32m1_t c = __riscv_vle32_v_i32m1_tu(b, in3, vl);
+    __riscv_vse32_v_i32m1(out, c, vl);
+  }
+}
+
+/* { dg-final { scan-assembler-times {vsetvli\s+zero,\s*[a-x0-9]+,\s*e32,\s*m1,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli\s+[a-x0-9]+,\s*zero,\s*e32,\s*m1,\s*tu,\s*m[au]} 1 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
+/* { dg-final { scan-assembler-times {vsetvli} 2 { target { no-opts "-O0" no-opts "-g" no-opts "-funroll-loops" } } } } */
diff --git a/gcc/testsuite/gfortran.dg/ISO_Fortran_binding_17.f90 b/gcc/testsuite/gfortran.dg/ISO_Fortran_binding_17.f90
index 5902334..c399e71 100644
--- a/gcc/testsuite/gfortran.dg/ISO_Fortran_binding_17.f90
+++ b/gcc/testsuite/gfortran.dg/ISO_Fortran_binding_17.f90
@@ -71,7 +71,7 @@
    end block blk2
 end
 
-! { dg-output "CFI_address: subscripts\\\[0\\\] is out of bounds. For dimension = 0, subscripts = -1, lower_bound = 0, upper bound = 4, extent = 4(\n|\r\n|\r)" }
-! { dg-output "CFI_address: subscripts\\\[0\\\] is out of bounds. For dimension = 0, subscripts = 5, lower_bound = 0, upper bound = 4, extent = 4(\n|\r\n|\r).*" }
-! { dg-output "CFI_address: subscripts\\\[0\\\] is out of bounds. For dimension = 0, subscripts = -3, lower_bound = -2, upper bound = 6, extent = 4(\n|\r\n|\r)" }
-! { dg-output "CFI_address: subscripts\\\[0\\\] is out of bounds. For dimension = 0, subscripts = 2, lower_bound = -2, upper bound = 6, extent = 4(\n|\r\n|\r)" }
+! { dg-output "CFI_address: subscripts\\\[0\\\] is out of bounds. For dimension = 0, subscripts = -1, lower_bound = 0, upper bound = 4, extent = 4(\r*\n+)" }
+! { dg-output "CFI_address: subscripts\\\[0\\\] is out of bounds. For dimension = 0, subscripts = 5, lower_bound = 0, upper bound = 4, extent = 4(\r*\n+).*" }
+! { dg-output "CFI_address: subscripts\\\[0\\\] is out of bounds. For dimension = 0, subscripts = -3, lower_bound = -2, upper bound = 6, extent = 4(\r*\n+)" }
+! { dg-output "CFI_address: subscripts\\\[0\\\] is out of bounds. For dimension = 0, subscripts = 2, lower_bound = -2, upper bound = 6, extent = 4(\r*\n+)" }
diff --git a/gcc/testsuite/gfortran.dg/array_temporaries_2.f90 b/gcc/testsuite/gfortran.dg/array_temporaries_2.f90
index 86e0a45..756e008 100644
--- a/gcc/testsuite/gfortran.dg/array_temporaries_2.f90
+++ b/gcc/testsuite/gfortran.dg/array_temporaries_2.f90
@@ -12,4 +12,4 @@ contains
   end subroutine foo
 end program test
 
-! { dg-output "At line 7 of file .*array_temporaries_2.f90(\n|\r\n|\r)Fortran runtime warning: An array temporary was created for argument 'x' of procedure 'foo'" }
+! { dg-output "At line 7 of file .*array_temporaries_2.f90(\r*\n+)Fortran runtime warning: An array temporary was created for argument 'x' of procedure 'foo'" }
diff --git a/gcc/testsuite/gfortran.dg/bind-c-contiguous-1.f90 b/gcc/testsuite/gfortran.dg/bind-c-contiguous-1.f90
index 77dd3a2..975f74b 100644
--- a/gcc/testsuite/gfortran.dg/bind-c-contiguous-1.f90
+++ b/gcc/testsuite/gfortran.dg/bind-c-contiguous-1.f90
@@ -1372,203 +1372,203 @@ if (any (a3 /= a_init)) error stop 58
 end
 
 
-! { dg-output "At line 928 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_size_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 928 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_size_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 928 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_size_f'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 946 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_size_in_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 946 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_size_in_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 946 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_size_in_f'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 965 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_expl_size_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 965 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_expl_size_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 965 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_expl_size_f'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 983 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_expl_size_in_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 983 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_expl_size_in_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 983 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_expl_size_in_f'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1039 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_rank_cont_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 1039 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_rank_cont_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 1039 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_rank_cont_f'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1057 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_rank_cont_in_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 1057 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_rank_cont_in_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 1057 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_rank_cont_in_f'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1113 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_shape_cont_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 1113 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_shape_cont_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 1113 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_shape_cont_f'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1131 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_shape_cont_in_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 1131 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_shape_cont_in_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 1131 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_shape_cont_in_f'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1153 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_size_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1153 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_size_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1153 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_size_c'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1171 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_size_in_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1171 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_size_in_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1171 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_size_in_c'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1190 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_expl_size_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1190 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_expl_size_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1190 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_expl_size_c'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1208 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_expl_size_in_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1208 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_expl_size_in_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1208 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_expl_size_in_c'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1264 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_rank_cont_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1264 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_rank_cont_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1264 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_rank_cont_c'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1282 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_rank_cont_in_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1282 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_rank_cont_in_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1282 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_rank_cont_in_c'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1338 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_shape_cont_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1338 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_shape_cont_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1338 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_shape_cont_c'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1356 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_shape_cont_in_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1356 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_shape_cont_in_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1356 of file .*bind-c-contiguous-1.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_shape_cont_in_c'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
+! { dg-output "At line 928 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_size_f'(\r*\n+)" }"
+! { dg-output "At line 928 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_size_f'(\r*\n+)" }"
+! { dg-output "At line 928 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_size_f'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 946 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_size_in_f'(\r*\n+)" }"
+! { dg-output "At line 946 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_size_in_f'(\r*\n+)" }"
+! { dg-output "At line 946 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_size_in_f'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 965 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_expl_size_f'(\r*\n+)" }"
+! { dg-output "At line 965 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_expl_size_f'(\r*\n+)" }"
+! { dg-output "At line 965 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_expl_size_f'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 983 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_expl_size_in_f'(\r*\n+)" }"
+! { dg-output "At line 983 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_expl_size_in_f'(\r*\n+)" }"
+! { dg-output "At line 983 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_expl_size_in_f'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1039 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_rank_cont_f'(\r*\n+)" }"
+! { dg-output "At line 1039 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_rank_cont_f'(\r*\n+)" }"
+! { dg-output "At line 1039 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_rank_cont_f'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1057 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_rank_cont_in_f'(\r*\n+)" }"
+! { dg-output "At line 1057 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_rank_cont_in_f'(\r*\n+)" }"
+! { dg-output "At line 1057 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_rank_cont_in_f'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1113 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_shape_cont_f'(\r*\n+)" }"
+! { dg-output "At line 1113 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_shape_cont_f'(\r*\n+)" }"
+! { dg-output "At line 1113 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_shape_cont_f'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1131 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_shape_cont_in_f'(\r*\n+)" }"
+! { dg-output "At line 1131 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_shape_cont_in_f'(\r*\n+)" }"
+! { dg-output "At line 1131 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_shape_cont_in_f'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1153 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_size_c'(\r*\n+)" }"
+! { dg-output "At line 1153 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_size_c'(\r*\n+)" }"
+! { dg-output "At line 1153 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_size_c'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1171 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_size_in_c'(\r*\n+)" }"
+! { dg-output "At line 1171 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_size_in_c'(\r*\n+)" }"
+! { dg-output "At line 1171 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_size_in_c'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1190 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_expl_size_c'(\r*\n+)" }"
+! { dg-output "At line 1190 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_expl_size_c'(\r*\n+)" }"
+! { dg-output "At line 1190 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_expl_size_c'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1208 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_expl_size_in_c'(\r*\n+)" }"
+! { dg-output "At line 1208 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_expl_size_in_c'(\r*\n+)" }"
+! { dg-output "At line 1208 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_expl_size_in_c'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1264 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_rank_cont_c'(\r*\n+)" }"
+! { dg-output "At line 1264 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_rank_cont_c'(\r*\n+)" }"
+! { dg-output "At line 1264 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_rank_cont_c'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1282 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_rank_cont_in_c'(\r*\n+)" }"
+! { dg-output "At line 1282 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_rank_cont_in_c'(\r*\n+)" }"
+! { dg-output "At line 1282 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_rank_cont_in_c'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1338 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_shape_cont_c'(\r*\n+)" }"
+! { dg-output "At line 1338 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_shape_cont_c'(\r*\n+)" }"
+! { dg-output "At line 1338 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_shape_cont_c'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1356 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_shape_cont_in_c'(\r*\n+)" }"
+! { dg-output "At line 1356 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_shape_cont_in_c'(\r*\n+)" }"
+! { dg-output "At line 1356 of file .*bind-c-contiguous-1.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_shape_cont_in_c'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
diff --git a/gcc/testsuite/gfortran.dg/bind-c-contiguous-4.f90 b/gcc/testsuite/gfortran.dg/bind-c-contiguous-4.f90
index ab59b0b..a58ba20 100644
--- a/gcc/testsuite/gfortran.dg/bind-c-contiguous-4.f90
+++ b/gcc/testsuite/gfortran.dg/bind-c-contiguous-4.f90
@@ -1518,203 +1518,203 @@ loc3 = char_assumed_shape_cont_in_c (k=len(a), num=3)
 if (loc3%x /= -1 .or. loc3%y /= -1 .or. loc3%z /= -1) error stop 2
 end
 
-! { dg-output "At line 1003 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_size_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 1003 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_size_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 1003 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_size_f'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1024 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_size_in_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 1024 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_size_in_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 1024 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_size_in_f'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1046 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_expl_size_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 1046 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_expl_size_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 1046 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_expl_size_f'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1067 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_expl_size_in_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 1067 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_expl_size_in_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 1067 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_expl_size_in_f'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1132 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_rank_cont_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 1132 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_rank_cont_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 1132 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_rank_cont_f'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1153 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_rank_cont_in_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 1153 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_rank_cont_in_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 1153 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_rank_cont_in_f'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1218 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_shape_cont_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 1218 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_shape_cont_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 1218 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_shape_cont_f'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1239 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_shape_cont_in_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 1239 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_shape_cont_in_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 1239 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_shape_cont_in_f'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1264 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_size_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1264 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_size_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1264 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_size_c'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1285 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_size_in_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1285 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_size_in_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1285 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_size_in_c'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1307 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_expl_size_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1307 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_expl_size_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1307 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_expl_size_c'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1328 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_expl_size_in_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1328 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_expl_size_in_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1328 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_expl_size_in_c'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1393 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_rank_cont_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1393 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_rank_cont_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1393 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_rank_cont_c'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1414 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_rank_cont_in_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1414 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_rank_cont_in_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1414 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_rank_cont_in_c'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1479 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_shape_cont_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1479 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_shape_cont_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1479 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_shape_cont_c'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1500 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_shape_cont_in_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1500 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_shape_cont_in_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1500 of file .*bind-c-contiguous-4.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_shape_cont_in_c'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
+! { dg-output "At line 1003 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_size_f'(\r*\n+)" }"
+! { dg-output "At line 1003 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_size_f'(\r*\n+)" }"
+! { dg-output "At line 1003 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_size_f'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1024 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_size_in_f'(\r*\n+)" }"
+! { dg-output "At line 1024 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_size_in_f'(\r*\n+)" }"
+! { dg-output "At line 1024 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_size_in_f'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1046 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_expl_size_f'(\r*\n+)" }"
+! { dg-output "At line 1046 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_expl_size_f'(\r*\n+)" }"
+! { dg-output "At line 1046 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_expl_size_f'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1067 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_expl_size_in_f'(\r*\n+)" }"
+! { dg-output "At line 1067 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_expl_size_in_f'(\r*\n+)" }"
+! { dg-output "At line 1067 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_expl_size_in_f'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1132 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_rank_cont_f'(\r*\n+)" }"
+! { dg-output "At line 1132 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_rank_cont_f'(\r*\n+)" }"
+! { dg-output "At line 1132 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_rank_cont_f'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1153 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_rank_cont_in_f'(\r*\n+)" }"
+! { dg-output "At line 1153 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_rank_cont_in_f'(\r*\n+)" }"
+! { dg-output "At line 1153 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_rank_cont_in_f'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1218 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_shape_cont_f'(\r*\n+)" }"
+! { dg-output "At line 1218 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_shape_cont_f'(\r*\n+)" }"
+! { dg-output "At line 1218 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_shape_cont_f'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1239 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_shape_cont_in_f'(\r*\n+)" }"
+! { dg-output "At line 1239 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_shape_cont_in_f'(\r*\n+)" }"
+! { dg-output "At line 1239 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_shape_cont_in_f'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1264 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_size_c'(\r*\n+)" }"
+! { dg-output "At line 1264 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_size_c'(\r*\n+)" }"
+! { dg-output "At line 1264 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_size_c'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1285 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_size_in_c'(\r*\n+)" }"
+! { dg-output "At line 1285 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_size_in_c'(\r*\n+)" }"
+! { dg-output "At line 1285 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_size_in_c'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1307 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_expl_size_c'(\r*\n+)" }"
+! { dg-output "At line 1307 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_expl_size_c'(\r*\n+)" }"
+! { dg-output "At line 1307 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_expl_size_c'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1328 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_expl_size_in_c'(\r*\n+)" }"
+! { dg-output "At line 1328 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_expl_size_in_c'(\r*\n+)" }"
+! { dg-output "At line 1328 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_expl_size_in_c'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1393 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_rank_cont_c'(\r*\n+)" }"
+! { dg-output "At line 1393 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_rank_cont_c'(\r*\n+)" }"
+! { dg-output "At line 1393 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_rank_cont_c'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1414 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_rank_cont_in_c'(\r*\n+)" }"
+! { dg-output "At line 1414 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_rank_cont_in_c'(\r*\n+)" }"
+! { dg-output "At line 1414 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_rank_cont_in_c'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1479 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_shape_cont_c'(\r*\n+)" }"
+! { dg-output "At line 1479 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_shape_cont_c'(\r*\n+)" }"
+! { dg-output "At line 1479 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_shape_cont_c'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1500 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_shape_cont_in_c'(\r*\n+)" }"
+! { dg-output "At line 1500 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_shape_cont_in_c'(\r*\n+)" }"
+! { dg-output "At line 1500 of file .*bind-c-contiguous-4.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_shape_cont_in_c'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
diff --git a/gcc/testsuite/gfortran.dg/bind-c-contiguous-5.f90 b/gcc/testsuite/gfortran.dg/bind-c-contiguous-5.f90
index 3eb2732..d1af9f7 100644
--- a/gcc/testsuite/gfortran.dg/bind-c-contiguous-5.f90
+++ b/gcc/testsuite/gfortran.dg/bind-c-contiguous-5.f90
@@ -1372,203 +1372,203 @@ if (any (a3 /= a_init)) error stop 58
 end
 
 
-! { dg-output "At line 928 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_size_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 928 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_size_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 928 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_size_f'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 946 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_size_in_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 946 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_size_in_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 946 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_size_in_f'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 965 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_expl_size_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 965 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_expl_size_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 965 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_expl_size_f'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 983 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_expl_size_in_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 983 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_expl_size_in_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 983 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_expl_size_in_f'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1039 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_rank_cont_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 1039 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_rank_cont_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 1039 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_rank_cont_f'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1057 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_rank_cont_in_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 1057 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_rank_cont_in_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 1057 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_rank_cont_in_f'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1113 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_shape_cont_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 1113 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_shape_cont_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 1113 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_shape_cont_f'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1131 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_shape_cont_in_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 1131 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_shape_cont_in_f'(\n|\r\n|\r)" }"
-! { dg-output "At line 1131 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_shape_cont_in_f'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1153 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_size_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1153 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_size_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1153 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_size_c'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1171 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_size_in_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1171 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_size_in_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1171 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_size_in_c'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1190 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_expl_size_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1190 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_expl_size_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1190 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_expl_size_c'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1208 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_expl_size_in_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1208 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_expl_size_in_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1208 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_expl_size_in_c'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1264 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_rank_cont_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1264 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_rank_cont_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1264 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_rank_cont_c'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1282 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_rank_cont_in_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1282 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_rank_cont_in_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1282 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_rank_cont_in_c'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1338 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_shape_cont_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1338 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_shape_cont_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1338 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_shape_cont_c'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
-! { dg-output "At line 1356 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_shape_cont_in_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1356 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_shape_cont_in_c'(\n|\r\n|\r)" }"
-! { dg-output "At line 1356 of file .*bind-c-contiguous-5.f90(\n|\r\n|\r)" }"
-! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_shape_cont_in_c'(\n|\r\n|\r)" }"
-! { dg-output " abcghinop(\n|\r\n|\r)" }"
-! { dg-output " defghijlm(\n|\r\n|\r)" }"
+! { dg-output "At line 928 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_size_f'(\r*\n+)" }"
+! { dg-output "At line 928 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_size_f'(\r*\n+)" }"
+! { dg-output "At line 928 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_size_f'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 946 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_size_in_f'(\r*\n+)" }"
+! { dg-output "At line 946 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_size_in_f'(\r*\n+)" }"
+! { dg-output "At line 946 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_size_in_f'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 965 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_expl_size_f'(\r*\n+)" }"
+! { dg-output "At line 965 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_expl_size_f'(\r*\n+)" }"
+! { dg-output "At line 965 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_expl_size_f'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 983 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_expl_size_in_f'(\r*\n+)" }"
+! { dg-output "At line 983 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_expl_size_in_f'(\r*\n+)" }"
+! { dg-output "At line 983 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_expl_size_in_f'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1039 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_rank_cont_f'(\r*\n+)" }"
+! { dg-output "At line 1039 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_rank_cont_f'(\r*\n+)" }"
+! { dg-output "At line 1039 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_rank_cont_f'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1057 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_rank_cont_in_f'(\r*\n+)" }"
+! { dg-output "At line 1057 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_rank_cont_in_f'(\r*\n+)" }"
+! { dg-output "At line 1057 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_rank_cont_in_f'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1113 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_shape_cont_f'(\r*\n+)" }"
+! { dg-output "At line 1113 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_shape_cont_f'(\r*\n+)" }"
+! { dg-output "At line 1113 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_shape_cont_f'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1131 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_shape_cont_in_f'(\r*\n+)" }"
+! { dg-output "At line 1131 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_shape_cont_in_f'(\r*\n+)" }"
+! { dg-output "At line 1131 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_shape_cont_in_f'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1153 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_size_c'(\r*\n+)" }"
+! { dg-output "At line 1153 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_size_c'(\r*\n+)" }"
+! { dg-output "At line 1153 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_size_c'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1171 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_size_in_c'(\r*\n+)" }"
+! { dg-output "At line 1171 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_size_in_c'(\r*\n+)" }"
+! { dg-output "At line 1171 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_size_in_c'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1190 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_expl_size_c'(\r*\n+)" }"
+! { dg-output "At line 1190 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_expl_size_c'(\r*\n+)" }"
+! { dg-output "At line 1190 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_expl_size_c'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1208 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_expl_size_in_c'(\r*\n+)" }"
+! { dg-output "At line 1208 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_expl_size_in_c'(\r*\n+)" }"
+! { dg-output "At line 1208 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_expl_size_in_c'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1264 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_rank_cont_c'(\r*\n+)" }"
+! { dg-output "At line 1264 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_rank_cont_c'(\r*\n+)" }"
+! { dg-output "At line 1264 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_rank_cont_c'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1282 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_rank_cont_in_c'(\r*\n+)" }"
+! { dg-output "At line 1282 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_rank_cont_in_c'(\r*\n+)" }"
+! { dg-output "At line 1282 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_rank_cont_in_c'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1338 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_shape_cont_c'(\r*\n+)" }"
+! { dg-output "At line 1338 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_shape_cont_c'(\r*\n+)" }"
+! { dg-output "At line 1338 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_shape_cont_c'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
+! { dg-output "At line 1356 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'xx' of procedure 'char_assumed_shape_cont_in_c'(\r*\n+)" }"
+! { dg-output "At line 1356 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'yy' of procedure 'char_assumed_shape_cont_in_c'(\r*\n+)" }"
+! { dg-output "At line 1356 of file .*bind-c-contiguous-5.f90(\r*\n+)" }"
+! { dg-output "Fortran runtime warning: An array temporary was created for argument 'zz' of procedure 'char_assumed_shape_cont_in_c'(\r*\n+)" }"
+! { dg-output " abcghinop(\r*\n+)" }"
+! { dg-output " defghijlm(\r*\n+)" }"
diff --git a/gcc/testsuite/gfortran.dg/common_27.f90 b/gcc/testsuite/gfortran.dg/common_27.f90
new file mode 100644
index 0000000..dcde5de
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/common_27.f90
@@ -0,0 +1,14 @@
+! { dg-do compile }
+! PR fortran/108453 - a use associated variable cannot occur in COMMON
+! Contributed by G.Steinmetz
+
+module m
+  type t
+  end type
+  real :: r
+end
+program p
+  use m, only: t, r
+  common t      ! { dg-error "USE associated from module" }
+  common /cm/ r ! { dg-error "USE associated from module" }
+end
diff --git a/gcc/testsuite/gfortran.dg/fmt_error_4.f90 b/gcc/testsuite/gfortran.dg/fmt_error_4.f90
index 2310573..6c44f10 100644
--- a/gcc/testsuite/gfortran.dg/fmt_error_4.f90
+++ b/gcc/testsuite/gfortran.dg/fmt_error_4.f90
@@ -19,4 +19,4 @@ PROGRAM main
   CALL format_runtime ('(A, Q, A)')
 END PROGRAM main
 
-! { dg-output "Unexpected element 'Q'.*(\n|\r\n|\r)\\(A, Q, A\\)(\n|\r\n|\r)    \\^" }
+! { dg-output "Unexpected element 'Q'.*(\r*\n+)\\(A, Q, A\\)(\r*\n+)    \\^" }
diff --git a/gcc/testsuite/gfortran.dg/fmt_error_5.f90 b/gcc/testsuite/gfortran.dg/fmt_error_5.f90
index 18de68e..1076baf 100644
--- a/gcc/testsuite/gfortran.dg/fmt_error_5.f90
+++ b/gcc/testsuite/gfortran.dg/fmt_error_5.f90
@@ -19,4 +19,4 @@ PROGRAM main
   CALL format_runtime ('(Q)')
 END PROGRAM main
 
-! { dg-output "Unexpected element 'Q'.*(\n|\r\n|\r)\\(Q\\)(\n|\r\n|\r) \\^" }
+! { dg-output "Unexpected element 'Q'.*(\r*\n+)\\(Q\\)(\r*\n+) \\^" }
diff --git a/gcc/testsuite/gfortran.dg/fmt_float.f90 b/gcc/testsuite/gfortran.dg/fmt_float.f90
index 3ff1833..ff3d28e 100644
--- a/gcc/testsuite/gfortran.dg/fmt_float.f90
+++ b/gcc/testsuite/gfortran.dg/fmt_float.f90
@@ -23,21 +23,21 @@ print '(3E20.4e5)', x, x/10.0, x/100.0
 print '(3E20.4e6)', x, x/10.0, x/100.0
 print '(3E20.4e7)', x, x/10.0, x/100.0
 end
-! { dg-output "            0.10E\\+01            0.10E\\+00            0.10E-01(\n|\r\n|\r)" }
-! { dg-output "           0.10E\\+001           0.10E\\+000           0.10E-001(\n|\r\n|\r)" }
-! { dg-output "          0.10E\\+0001          0.10E\\+0000          0.10E-0001(\n|\r\n|\r)" }
-! { dg-output "         0.10E\\+00001         0.10E\\+00000         0.10E-00001(\n|\r\n|\r)" }
-! { dg-output "        0.10E\\+000001        0.10E\\+000000        0.10E-000001(\n|\r\n|\r)" }
-! { dg-output "       0.10E\\+0000001       0.10E\\+0000000       0.10E-0000001(\n|\r\n|\r)" }
-! { dg-output "           0.100E\\+01           0.100E\\+00           0.100E-01(\n|\r\n|\r)" }
-! { dg-output "          0.100E\\+001          0.100E\\+000          0.100E-001(\n|\r\n|\r)" }
-! { dg-output "         0.100E\\+0001         0.100E\\+0000         0.100E-0001(\n|\r\n|\r)" }
-! { dg-output "        0.100E\\+00001        0.100E\\+00000        0.100E-00001(\n|\r\n|\r)" }
-! { dg-output "       0.100E\\+000001       0.100E\\+000000       0.100E-000001(\n|\r\n|\r)" }
-! { dg-output "      0.100E\\+0000001      0.100E\\+0000000      0.100E-0000001(\n|\r\n|\r)" }
-! { dg-output "          0.1000E\\+01          0.1000E\\+00          0.1000E-01(\n|\r\n|\r)" }
-! { dg-output "         0.1000E\\+001         0.1000E\\+000         0.1000E-001(\n|\r\n|\r)" }
-! { dg-output "        0.1000E\\+0001        0.1000E\\+0000        0.1000E-0001(\n|\r\n|\r)" }
-! { dg-output "       0.1000E\\+00001       0.1000E\\+00000       0.1000E-00001(\n|\r\n|\r)" }
-! { dg-output "      0.1000E\\+000001      0.1000E\\+000000      0.1000E-000001(\n|\r\n|\r)" }
-! { dg-output "     0.1000E\\+0000001     0.1000E\\+0000000     0.1000E-0000001(\n|\r\n|\r)" }
+! { dg-output "            0.10E\\+01            0.10E\\+00            0.10E-01(\r*\n+)" }
+! { dg-output "           0.10E\\+001           0.10E\\+000           0.10E-001(\r*\n+)" }
+! { dg-output "          0.10E\\+0001          0.10E\\+0000          0.10E-0001(\r*\n+)" }
+! { dg-output "         0.10E\\+00001         0.10E\\+00000         0.10E-00001(\r*\n+)" }
+! { dg-output "        0.10E\\+000001        0.10E\\+000000        0.10E-000001(\r*\n+)" }
+! { dg-output "       0.10E\\+0000001       0.10E\\+0000000       0.10E-0000001(\r*\n+)" }
+! { dg-output "           0.100E\\+01           0.100E\\+00           0.100E-01(\r*\n+)" }
+! { dg-output "          0.100E\\+001          0.100E\\+000          0.100E-001(\r*\n+)" }
+! { dg-output "         0.100E\\+0001         0.100E\\+0000         0.100E-0001(\r*\n+)" }
+! { dg-output "        0.100E\\+00001        0.100E\\+00000        0.100E-00001(\r*\n+)" }
+! { dg-output "       0.100E\\+000001       0.100E\\+000000       0.100E-000001(\r*\n+)" }
+! { dg-output "      0.100E\\+0000001      0.100E\\+0000000      0.100E-0000001(\r*\n+)" }
+! { dg-output "          0.1000E\\+01          0.1000E\\+00          0.1000E-01(\r*\n+)" }
+! { dg-output "         0.1000E\\+001         0.1000E\\+000         0.1000E-001(\r*\n+)" }
+! { dg-output "        0.1000E\\+0001        0.1000E\\+0000        0.1000E-0001(\r*\n+)" }
+! { dg-output "       0.1000E\\+00001       0.1000E\\+00000       0.1000E-00001(\r*\n+)" }
+! { dg-output "      0.1000E\\+000001      0.1000E\\+000000      0.1000E-000001(\r*\n+)" }
+! { dg-output "     0.1000E\\+0000001     0.1000E\\+0000000     0.1000E-0000001(\r*\n+)" }
diff --git a/gcc/testsuite/gfortran.dg/fmt_l.f90 b/gcc/testsuite/gfortran.dg/fmt_l.f90
index ffefa0d..5ca313f 100644
--- a/gcc/testsuite/gfortran.dg/fmt_l.f90
+++ b/gcc/testsuite/gfortran.dg/fmt_l.f90
@@ -52,34 +52,34 @@ program test_l
 
 end program test_l
 ! { dg-output "At line 14 of file.*" }
-! { dg-output "Fortran runtime warning: Positive width required with L descriptor(\n|\r\n|\r)" }
+! { dg-output "Fortran runtime warning: Positive width required with L descriptor(\r*\n+)" }
 ! { dg-output "At line 15 of file.*" }
-! { dg-output "Fortran runtime warning: Positive width required with L descriptor(\n|\r\n|\r)" }
+! { dg-output "Fortran runtime warning: Positive width required with L descriptor(\r*\n+)" }
 ! { dg-output "At line 19 of file.*" }
-! { dg-output "Fortran runtime warning: Positive width required with L descriptor(\n|\r\n|\r)" }
+! { dg-output "Fortran runtime warning: Positive width required with L descriptor(\r*\n+)" }
 ! { dg-output "At line 20 of file.*" }
-! { dg-output "Fortran runtime warning: Positive width required with L descriptor(\n|\r\n|\r)" }
+! { dg-output "Fortran runtime warning: Positive width required with L descriptor(\r*\n+)" }
 ! { dg-output "At line 24 of file.*" }
-! { dg-output "Fortran runtime warning: Positive width required with L descriptor(\n|\r\n|\r)" }
+! { dg-output "Fortran runtime warning: Positive width required with L descriptor(\r*\n+)" }
 ! { dg-output "At line 25 of file.*" }
-! { dg-output "Fortran runtime warning: Positive width required with L descriptor(\n|\r\n|\r)" }
+! { dg-output "Fortran runtime warning: Positive width required with L descriptor(\r*\n+)" }
 ! { dg-output "At line 29 of file.*" }
-! { dg-output "Fortran runtime warning: Positive width required with L descriptor(\n|\r\n|\r)" }
+! { dg-output "Fortran runtime warning: Positive width required with L descriptor(\r*\n+)" }
 ! { dg-output "At line 30 of file.*" }
-! { dg-output "Fortran runtime warning: Positive width required with L descriptor(\n|\r\n|\r)" }
+! { dg-output "Fortran runtime warning: Positive width required with L descriptor(\r*\n+)" }
 ! { dg-output "At line 34 of file.*" }
-! { dg-output "Fortran runtime warning: Positive width required with L descriptor(\n|\r\n|\r)" }
+! { dg-output "Fortran runtime warning: Positive width required with L descriptor(\r*\n+)" }
 ! { dg-output "At line 35 of file.*" }
-! { dg-output "Fortran runtime warning: Positive width required with L descriptor(\n|\r\n|\r)" }
+! { dg-output "Fortran runtime warning: Positive width required with L descriptor(\r*\n+)" }
 ! { dg-output "At line 39 of file.*" }
-! { dg-output "Fortran runtime warning: Positive width required with L descriptor(\n|\r\n|\r)" }
+! { dg-output "Fortran runtime warning: Positive width required with L descriptor(\r*\n+)" }
 ! { dg-output "At line 40 of file.*" }
-! { dg-output "Fortran runtime warning: Positive width required with L descriptor(\n|\r\n|\r)" }
+! { dg-output "Fortran runtime warning: Positive width required with L descriptor(\r*\n+)" }
 ! { dg-output "At line 44 of file.*" }
-! { dg-output "Fortran runtime warning: Positive width required with L descriptor(\n|\r\n|\r)" }
+! { dg-output "Fortran runtime warning: Positive width required with L descriptor(\r*\n+)" }
 ! { dg-output "At line 45 of file.*" }
-! { dg-output "Fortran runtime warning: Positive width required with L descriptor(\n|\r\n|\r)" }
+! { dg-output "Fortran runtime warning: Positive width required with L descriptor(\r*\n+)" }
 ! { dg-output "At line 49 of file.*" }
-! { dg-output "Fortran runtime warning: Positive width required with L descriptor(\n|\r\n|\r)" }
+! { dg-output "Fortran runtime warning: Positive width required with L descriptor(\r*\n+)" }
 ! { dg-output "At line 50 of file.*" }
-! { dg-output "Fortran runtime warning: Positive width required with L descriptor(\n|\r\n|\r)" }
+! { dg-output "Fortran runtime warning: Positive width required with L descriptor(\r*\n+)" }
diff --git a/gcc/testsuite/gfortran.dg/fmt_nonchar_2.f90 b/gcc/testsuite/gfortran.dg/fmt_nonchar_2.f90
index 7c0f524..6aee861 100644
--- a/gcc/testsuite/gfortran.dg/fmt_nonchar_2.f90
+++ b/gcc/testsuite/gfortran.dg/fmt_nonchar_2.f90
@@ -19,4 +19,4 @@ program p
    print x%a(1) ! { dg-warning "Legacy Extension: Non-character in FORMAT" }
 end
 
-! { dg-output "hello W2(\n|\r\n|\r)hello W3(\n|\r\n|\r)hello W1" }
+! { dg-output "hello W2(\r*\n+)hello W3(\r*\n+)hello W1" }
diff --git a/gcc/testsuite/gfortran.dg/fmt_zero_precision.f90 b/gcc/testsuite/gfortran.dg/fmt_zero_precision.f90
index 459bca4..b522698 100644
--- a/gcc/testsuite/gfortran.dg/fmt_zero_precision.f90
+++ b/gcc/testsuite/gfortran.dg/fmt_zero_precision.f90
@@ -46,40 +46,40 @@
  250   format(1pe7.0,"<")
  300   format(1pe6.0,"<")
   end
-! { dg-output " 1\\.<(\n|\r\n|\r)" }
-! { dg-output "-1\\.<(\n|\r\n|\r)" }
-! { dg-output "-9\\.<(\n|\r\n|\r)" }
-! { dg-output "-1\\.<(\n|\r\n|\r)" }
-! { dg-output "-1\\.<(\n|\r\n|\r)" }
-! { dg-output "-1\\.<(\n|\r\n|\r)" }
-! { dg-output "-1\\.<(\n|\r\n|\r)" }
-! { dg-output "-0\\.<(\n|\r\n|\r)" }
-! { dg-output "     38\\.<(\n|\r\n|\r)" }
-! { dg-output "  10345\\.<(\n|\r\n|\r)" }
-! { dg-output "    334\\.<(\n|\r\n|\r)" }
-! { dg-output "    333\\.<(\n|\r\n|\r)" }
-! { dg-output "1\\.E-01(\n|\r\n|\r)" }
-! { dg-output "-1\\.E\\+00<(\n|\r\n|\r)" }
-! { dg-output " 1\\.E\\+00<(\n|\r\n|\r)" }
-! { dg-output "-9\\.E\\+00<(\n|\r\n|\r)" }
-! { dg-output "-1\\.E\\+00<(\n|\r\n|\r)" }
-! { dg-output "-1\\.E\\+00<(\n|\r\n|\r)" }
-! { dg-output "-1\\.E\\+00<(\n|\r\n|\r)" }
-! { dg-output "-6\\.E-01<(\n|\r\n|\r)" }
-! { dg-output "-5\\.E-01<(\n|\r\n|\r)" }
-! { dg-output "  4\\.E\\+01<(\n|\r\n|\r)" }
-! { dg-output "  1\\.E\\+04<(\n|\r\n|\r)" }
-! { dg-output "  3\\.E\\+02<(\n|\r\n|\r)" }
-! { dg-output "  3\\.E\\+02<(\n|\r\n|\r)" }
-! { dg-output "-1\\.E\\+00<(\n|\r\n|\r)" }
-! { dg-output " 1\\.E\\+00<(\n|\r\n|\r)" }
-! { dg-output "-9\\.E\\+00<(\n|\r\n|\r)" }
-! { dg-output "-1\\.E\\+00<(\n|\r\n|\r)" }
-! { dg-output "-1\\.E\\+00<(\n|\r\n|\r)" }
-! { dg-output "-1\\.E\\+00<(\n|\r\n|\r)" }
-! { dg-output "-6\\.E-01<(\n|\r\n|\r)" }
-! { dg-output "-5\\.E-01<(\n|\r\n|\r)" }
-! { dg-output "4\\.E\\+01<(\n|\r\n|\r)" }
-! { dg-output "1\\.E\\+04<(\n|\r\n|\r)" }
-! { dg-output "3\\.E\\+02<(\n|\r\n|\r)" }
-! { dg-output "3\\.E\\+02<(\n|\r\n|\r)" }
+! { dg-output " 1\\.<(\r*\n+)" }
+! { dg-output "-1\\.<(\r*\n+)" }
+! { dg-output "-9\\.<(\r*\n+)" }
+! { dg-output "-1\\.<(\r*\n+)" }
+! { dg-output "-1\\.<(\r*\n+)" }
+! { dg-output "-1\\.<(\r*\n+)" }
+! { dg-output "-1\\.<(\r*\n+)" }
+! { dg-output "-0\\.<(\r*\n+)" }
+! { dg-output "     38\\.<(\r*\n+)" }
+! { dg-output "  10345\\.<(\r*\n+)" }
+! { dg-output "    334\\.<(\r*\n+)" }
+! { dg-output "    333\\.<(\r*\n+)" }
+! { dg-output "1\\.E-01(\r*\n+)" }
+! { dg-output "-1\\.E\\+00<(\r*\n+)" }
+! { dg-output " 1\\.E\\+00<(\r*\n+)" }
+! { dg-output "-9\\.E\\+00<(\r*\n+)" }
+! { dg-output "-1\\.E\\+00<(\r*\n+)" }
+! { dg-output "-1\\.E\\+00<(\r*\n+)" }
+! { dg-output "-1\\.E\\+00<(\r*\n+)" }
+! { dg-output "-6\\.E-01<(\r*\n+)" }
+! { dg-output "-5\\.E-01<(\r*\n+)" }
+! { dg-output "  4\\.E\\+01<(\r*\n+)" }
+! { dg-output "  1\\.E\\+04<(\r*\n+)" }
+! { dg-output "  3\\.E\\+02<(\r*\n+)" }
+! { dg-output "  3\\.E\\+02<(\r*\n+)" }
+! { dg-output "-1\\.E\\+00<(\r*\n+)" }
+! { dg-output " 1\\.E\\+00<(\r*\n+)" }
+! { dg-output "-9\\.E\\+00<(\r*\n+)" }
+! { dg-output "-1\\.E\\+00<(\r*\n+)" }
+! { dg-output "-1\\.E\\+00<(\r*\n+)" }
+! { dg-output "-1\\.E\\+00<(\r*\n+)" }
+! { dg-output "-6\\.E-01<(\r*\n+)" }
+! { dg-output "-5\\.E-01<(\r*\n+)" }
+! { dg-output "4\\.E\\+01<(\r*\n+)" }
+! { dg-output "1\\.E\\+04<(\r*\n+)" }
+! { dg-output "3\\.E\\+02<(\r*\n+)" }
+! { dg-output "3\\.E\\+02<(\r*\n+)" }
diff --git a/gcc/testsuite/gfortran.dg/g77/f77-edit-apostrophe-out.f b/gcc/testsuite/gfortran.dg/g77/f77-edit-apostrophe-out.f
index aa51bc0..3a5c10b 100644
--- a/gcc/testsuite/gfortran.dg/g77/f77-edit-apostrophe-out.f
+++ b/gcc/testsuite/gfortran.dg/g77/f77-edit-apostrophe-out.f
@@ -11,11 +11,11 @@ C { dg-output "^" }
  40   format('a trailing apostrophe''')
  50   format('''and all of the above -''-''')
 
-      write(*,10)        ! { dg-output "abcde(\n|\r\n|\r)" } 
-      write(*,20)        ! { dg-output "and an apostrophe -'-(\n|\r\n|\r)" }
-      write(*,30)        ! { dg-output "'a leading apostrophe(\n|\r\n|\r)" }
-      write(*,40)        ! { dg-output "a trailing apostrophe'(\n|\r\n|\r)" }
-      write(*,50)        ! { dg-output "'and all of the above -'-'(\n|\r\n|\r)" }
+      write(*,10)        ! { dg-output "abcde(\r*\n+)" } 
+      write(*,20)        ! { dg-output "and an apostrophe -'-(\r*\n+)" }
+      write(*,30)        ! { dg-output "'a leading apostrophe(\r*\n+)" }
+      write(*,40)        ! { dg-output "a trailing apostrophe'(\r*\n+)" }
+      write(*,50)        ! { dg-output "'and all of the above -'-'(\r*\n+)" }
 
 C { dg-output "\$" }
       end
diff --git a/gcc/testsuite/gfortran.dg/g77/f77-edit-colon-out.f b/gcc/testsuite/gfortran.dg/g77/f77-edit-colon-out.f
index 4feef75..c4e8e7f 100644
--- a/gcc/testsuite/gfortran.dg/g77/f77-edit-colon-out.f
+++ b/gcc/testsuite/gfortran.dg/g77/f77-edit-colon-out.f
@@ -4,6 +4,6 @@ C
 C Origin: David Billinghurst <David.Billinghurst@riotinto.com>
 C
 C { dg-do run }
-C { dg-output "^123(\n|\r\n|\r)45(\n|\r\n|\r)\$" }
+C { dg-output "^123(\r*\n+)45(\r*\n+)\$" }
       write(*,'((3(I1:)))')  (I,I=1,5)
       end
diff --git a/gcc/testsuite/gfortran.dg/g77/f77-edit-h-out.f b/gcc/testsuite/gfortran.dg/g77/f77-edit-h-out.f
index 78e6f01..f92b39f 100644
--- a/gcc/testsuite/gfortran.dg/g77/f77-edit-h-out.f
+++ b/gcc/testsuite/gfortran.dg/g77/f77-edit-h-out.f
@@ -7,8 +7,8 @@ C { dg-do run }
 C { dg-output "^" }
  10   format(1H1)
  20   format(6H     6)
-      write(*,10)        ! { dg-output "1(\n|\r\n|\r)" }
-      write(*,20)        ! { dg-output "     6(\n|\r\n|\r)" }
-      write(*,'(16H''apostrophe'' fun)') ! { dg-output "'apostrophe' fun(\n|\r\n|\r)" }
+      write(*,10)        ! { dg-output "1(\r*\n+)" }
+      write(*,20)        ! { dg-output "     6(\r*\n+)" }
+      write(*,'(16H''apostrophe'' fun)') ! { dg-output "'apostrophe' fun(\r*\n+)" }
 C { dg-output "\$" }
       end
diff --git a/gcc/testsuite/gfortran.dg/g77/f77-edit-i-out.f b/gcc/testsuite/gfortran.dg/g77/f77-edit-i-out.f
index 9887704..45a900b 100644
--- a/gcc/testsuite/gfortran.dg/g77/f77-edit-i-out.f
+++ b/gcc/testsuite/gfortran.dg/g77/f77-edit-i-out.f
@@ -6,21 +6,21 @@ C
 C { dg-do run }
 C { dg-output "^" }
 
-      write(*,'(I1)')    1  ! { dg-output "1(\n|\r\n|\r)" }
-      write(*,'(I1)')   -1  ! { dg-output "\\*(\n|\r\n|\r)" }
-      write(*,'(I2)')    2  ! { dg-output " 2(\n|\r\n|\r)" }
-      write(*,'(I2)')   -2  ! { dg-output "-2(\n|\r\n|\r)" }
-      write(*,'(I3)')    3  ! { dg-output "  3(\n|\r\n|\r)" }
-      write(*,'(I3)')   -3  ! { dg-output " -3(\n|\r\n|\r)" }
+      write(*,'(I1)')    1  ! { dg-output "1(\r*\n+)" }
+      write(*,'(I1)')   -1  ! { dg-output "\\*(\r*\n+)" }
+      write(*,'(I2)')    2  ! { dg-output " 2(\r*\n+)" }
+      write(*,'(I2)')   -2  ! { dg-output "-2(\r*\n+)" }
+      write(*,'(I3)')    3  ! { dg-output "  3(\r*\n+)" }
+      write(*,'(I3)')   -3  ! { dg-output " -3(\r*\n+)" }
 
-      write(*,'(I2.0)')  0  ! { dg-output "  (\n|\r\n|\r)" }
-      write(*,'(I1.1)')  4  ! { dg-output "4(\n|\r\n|\r)" }
-      write(*,'(I1.1)') -4  ! { dg-output "\\*(\n|\r\n|\r)" }
-      write(*,'(I2.1)')  5  ! { dg-output " 5(\n|\r\n|\r)" }
-      write(*,'(I2.1)') -5  ! { dg-output "-5(\n|\r\n|\r)" }
-      write(*,'(I2.2)')  6  ! { dg-output "06(\n|\r\n|\r)" }
-      write(*,'(I2.2)') -6  ! { dg-output "\\*\\*(\n|\r\n|\r)" }
-      write(*,'(I3.2)')  7  ! { dg-output " 07(\n|\r\n|\r)" }
-      write(*,'(I3.2)') -7  ! { dg-output "-07(\n|\r\n|\r)" }
+      write(*,'(I2.0)')  0  ! { dg-output "  (\r*\n+)" }
+      write(*,'(I1.1)')  4  ! { dg-output "4(\r*\n+)" }
+      write(*,'(I1.1)') -4  ! { dg-output "\\*(\r*\n+)" }
+      write(*,'(I2.1)')  5  ! { dg-output " 5(\r*\n+)" }
+      write(*,'(I2.1)') -5  ! { dg-output "-5(\r*\n+)" }
+      write(*,'(I2.2)')  6  ! { dg-output "06(\r*\n+)" }
+      write(*,'(I2.2)') -6  ! { dg-output "\\*\\*(\r*\n+)" }
+      write(*,'(I3.2)')  7  ! { dg-output " 07(\r*\n+)" }
+      write(*,'(I3.2)') -7  ! { dg-output "-07(\r*\n+)" }
 
       end
diff --git a/gcc/testsuite/gfortran.dg/g77/f77-edit-s-out.f b/gcc/testsuite/gfortran.dg/g77/f77-edit-s-out.f
index 7a22ae6..00249e7 100644
--- a/gcc/testsuite/gfortran.dg/g77/f77-edit-s-out.f
+++ b/gcc/testsuite/gfortran.dg/g77/f77-edit-s-out.f
@@ -10,11 +10,11 @@ C { dg-output "^" }
  30   format(SP,I3,1X,SS,I3,S,I3)
  40   format(SP,I3)
  50   format(SP,I2)
-      write(*,10) 10, 20      ! { dg-output "\\+10  20(\n|\r\n|\r)" }
-      write(*,20) 10, 20, 30  ! { dg-output "\\+10  20\\+30(\n|\r\n|\r)" }
-      write(*,30) 10, 20, 30  ! { dg-output "\\+10  20 30(\n|\r\n|\r)" } 
-      write(*,40) 0           ! { dg-output " \\+0(\n|\r\n|\r)" }
+      write(*,10) 10, 20      ! { dg-output "\\+10  20(\r*\n+)" }
+      write(*,20) 10, 20, 30  ! { dg-output "\\+10  20\\+30(\r*\n+)" }
+      write(*,30) 10, 20, 30  ! { dg-output "\\+10  20 30(\r*\n+)" } 
+      write(*,40) 0           ! { dg-output " \\+0(\r*\n+)" }
 C 15.5.9 - Note 5: When SP editing is in effect, the plus sign is not optional
-      write(*,50) 11          ! { dg-output "\\*\\*(\n|\r\n|\r)" }
+      write(*,50) 11          ! { dg-output "\\*\\*(\r*\n+)" }
 C { dg-output "\$" }
       end
diff --git a/gcc/testsuite/gfortran.dg/g77/f77-edit-slash-out.f b/gcc/testsuite/gfortran.dg/g77/f77-edit-slash-out.f
index 6cc9a88..ef8ac5e 100644
--- a/gcc/testsuite/gfortran.dg/g77/f77-edit-slash-out.f
+++ b/gcc/testsuite/gfortran.dg/g77/f77-edit-slash-out.f
@@ -4,6 +4,6 @@ C
 C Origin: David Billinghurst <David.Billinghurst@riotinto.com>
 C
 C { dg-do run }
-C { dg-output "^123(\n|\r\n|\r)45(\n|\r\n|\r)\$" }
+C { dg-output "^123(\r*\n+)45(\r*\n+)\$" }
       write(*,'(3(I1)/2(I1))')  (I,I=1,5)
       end
diff --git a/gcc/testsuite/gfortran.dg/g77/f77-edit-t-out.f b/gcc/testsuite/gfortran.dg/g77/f77-edit-t-out.f
index b47b747..d720936 100644
--- a/gcc/testsuite/gfortran.dg/g77/f77-edit-t-out.f
+++ b/gcc/testsuite/gfortran.dg/g77/f77-edit-t-out.f
@@ -5,8 +5,8 @@ C Origin: David Billinghurst <David.Billinghurst@riotinto.com>
 C
 C { dg-do run }
 C { dg-output "^" }
-      write(*,'(I4,T8,I1)')     1234,8 ! { dg-output "1234   8(\n|\r\n|\r)" }
-      write(*,'(I4,TR3,I1)')    1234,8 ! { dg-output "1234   8(\n|\r\n|\r)" }
-      write(*,'(I4,5X,TL2,I1)') 1234,8 ! { dg-output "1234   8(\n|\r\n|\r)" }
+      write(*,'(I4,T8,I1)')     1234,8 ! { dg-output "1234   8(\r*\n+)" }
+      write(*,'(I4,TR3,I1)')    1234,8 ! { dg-output "1234   8(\r*\n+)" }
+      write(*,'(I4,5X,TL2,I1)') 1234,8 ! { dg-output "1234   8(\r*\n+)" }
 C { dg-output "\$" }
       end
diff --git a/gcc/testsuite/gfortran.dg/g77/f77-edit-x-out.f b/gcc/testsuite/gfortran.dg/g77/f77-edit-x-out.f
index 13a9d7a..2096fb0 100644
--- a/gcc/testsuite/gfortran.dg/g77/f77-edit-x-out.f
+++ b/gcc/testsuite/gfortran.dg/g77/f77-edit-x-out.f
@@ -5,8 +5,8 @@ C Origin: David Billinghurst <David.Billinghurst@riotinto.com>
 C
 C { dg-do run } 
 C { dg-output "^" }
-      write(*,'(I1,1X,I1,2X,I1)') 1,2,3    ! { dg-output "1 2  3(\n|\r\n|\r)" }
+      write(*,'(I1,1X,I1,2X,I1)') 1,2,3    ! { dg-output "1 2  3(\r*\n+)" }
 C Section 13.5.3 explains why there are no trailing blanks
-      write(*,'(I1,1X,I1,2X,I1,3X)') 1,2,3 ! { dg-output "1 2  3(\n|\r\n|\r)" }
+      write(*,'(I1,1X,I1,2X,I1,3X)') 1,2,3 ! { dg-output "1 2  3(\r*\n+)" }
 C { dg-output "\$" }
       end
diff --git a/gcc/testsuite/gfortran.dg/gomp/declare-variant-10.f90 b/gcc/testsuite/gfortran.dg/gomp/declare-variant-10.f90
index d6d2c8c..2f09146 100644
--- a/gcc/testsuite/gfortran.dg/gomp/declare-variant-10.f90
+++ b/gcc/testsuite/gfortran.dg/gomp/declare-variant-10.f90
@@ -69,8 +69,8 @@ contains
 #endif
   subroutine test2 ()
     !$omp target
-      call f04 ()	! { dg-final { scan-tree-dump-times "f03 \\\(\\\);" 1 "gimple" { target { { i?86-*-* x86_64-*-* } && lp64 } } } }
-			! { dg-final { scan-tree-dump-times "f04 \\\(\\\);" 1 "gimple" { target { { ! lp64 } || { ! { i?86-*-* x86_64-*-* } } } } } }
+      call f04 () ! { dg-final { scan-tree-dump-times "f03 \\\(\\\);" 1 "gimple" { target { { i?86-*-* x86_64-*-* } && { ! ilp32 } } } } }
+                  ! { dg-final { scan-tree-dump-times "f04 \\\(\\\);" 1 "gimple" { target { { ilp32 } || { ! { i?86-*-* x86_64-*-* } } } } } }
     !$omp end target
     !$omp target
       call f16 ()	! { dg-final { scan-tree-dump-times "f15 \\\(\\\);" 1 "gimple" { target ia32 } } }
diff --git a/gcc/testsuite/gfortran.dg/gomp/declare-variant-11.f90 b/gcc/testsuite/gfortran.dg/gomp/declare-variant-11.f90
index 60aa0fc..3593c9a 100644
--- a/gcc/testsuite/gfortran.dg/gomp/declare-variant-11.f90
+++ b/gcc/testsuite/gfortran.dg/gomp/declare-variant-11.f90
@@ -126,8 +126,8 @@ contains
     end do
     !$omp end parallel do
 
-    call f27 ()	! { dg-final { scan-tree-dump-times "f25 \\\(\\\);" 1 "gimple" { target { { i?86-*-* x86_64-*-* } && lp64 } } } }
-		! { dg-final { scan-tree-dump-times "f24 \\\(\\\);" 1 "gimple" { target { { i?86-*-* x86_64-*-* } && { ! lp64 } } } } }
+    call f27 () ! { dg-final { scan-tree-dump-times "f25 \\\(\\\);" 1 "gimple" { target { { i?86-*-* x86_64-*-* } && { ! ilp32 } } } } }
+                ! { dg-final { scan-tree-dump-times "f24 \\\(\\\);" 1 "gimple" { target { { i?86-*-* x86_64-*-* } && { ilp32 } } } } }
 		! { dg-final { scan-tree-dump-times "f24 \\\(\\\);" 1 "gimple" { target { ! { nvptx*-*-* amdgcn*-*-* i?86-*-* x86_64-*-* } } } } }
 		! { dg-final { scan-tree-dump-times "f27 \\\(\\\);" 1 "gimple" { target { nvptx*-*-* amdgcn*-*-* } } } }
   end subroutine
diff --git a/gcc/testsuite/gfortran.dg/gomp/declare-variant-12.f90 b/gcc/testsuite/gfortran.dg/gomp/declare-variant-12.f90
index 610693e..2fd8abd 100644
--- a/gcc/testsuite/gfortran.dg/gomp/declare-variant-12.f90
+++ b/gcc/testsuite/gfortran.dg/gomp/declare-variant-12.f90
@@ -133,8 +133,8 @@ contains
     do i = 1, 2
       !$omp parallel do	! 5 constructs in OpenMP context, arch is 2^6, isa 2^7.
       do j = 1, 2
-	  call f13 ()	! { dg-final { scan-tree-dump-times "f09 \\\(\\\);" 1 "gimple" { target { { i?86-*-* x86_64-*-* } && lp64 } } } }
-			! { dg-final { scan-tree-dump-times "f11 \\\(\\\);" 1 "gimple" { target { { i?86-*-* x86_64-*-* } && { ! lp64 } } } } }
+          call f13 ()   ! { dg-final { scan-tree-dump-times "f09 \\\(\\\);" 1 "gimple" { target { { i?86-*-* x86_64-*-* } && { ! ilp32 } } } } }
+                        ! { dg-final { scan-tree-dump-times "f11 \\\(\\\);" 1 "gimple" { target { { i?86-*-* x86_64-*-* } && { ilp32 } } } } }
 			! { dg-final { scan-tree-dump-times "f10 \\\(\\\);" 1 "gimple" { target { ! { i?86-*-* x86_64-*-* } } } } }
 	  call f17 ()	! { dg-final { scan-tree-dump-times "f14 \\\(\\\);" 1 "gimple" } }
 	  call f21 ()	! { dg-final { scan-tree-dump-times "f19 \\\(\\\);" 1 "gimple" } }
diff --git a/gcc/testsuite/gfortran.dg/gomp/minmaxloc_1.f90 b/gcc/testsuite/gfortran.dg/gomp/minmaxloc_1.f90
new file mode 100644
index 0000000..b3691f7
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gomp/minmaxloc_1.f90
@@ -0,0 +1,32 @@
+! { dg-do compile }
+!
+! PR fortran/108450
+! This program used to cause an ICE because of the double resolution
+! of the maxloc expression and the addition of a hidden unnamed argument
+! during the first resolution.
+!
+! Original testcase from G. Steinmetz
+
+subroutine s1
+   integer :: a(8) = 0
+   integer :: l
+   integer :: n
+   !$omp atomic
+   n = maxloc(a, mask=l) ! { dg-error ".mask. argument of .maxloc. intrinsic at .1. must be LOGICAL" }
+end
+
+subroutine s2
+   integer :: a(8) = 0
+   integer :: l
+   integer :: n
+   !$omp atomic
+   n = minloc(a, mask=l) ! { dg-error ".mask. argument of .minloc. intrinsic at .1. must be LOGICAL" }
+end
+
+subroutine s3
+   integer :: a(8) = 0
+   integer :: l
+   integer :: n
+   !$omp atomic
+   n = findloc(a, 3, mask=l) ! { dg-error ".mask. argument of .findloc. intrinsic at .1. must be LOGICAL" }
+end
diff --git a/gcc/testsuite/gfortran.dg/namelist_40.f90 b/gcc/testsuite/gfortran.dg/namelist_40.f90
index 23b3e72..ba28d29 100644
--- a/gcc/testsuite/gfortran.dg/namelist_40.f90
+++ b/gcc/testsuite/gfortran.dg/namelist_40.f90
@@ -47,7 +47,7 @@ subroutine writenml (astring)
 end subroutine writenml
 
 end program namelist_40
-! { dg-output "Multiple sub-objects with non-zero rank in namelist object x%m%ch(\n|\r\n|\r)" }
-! { dg-output "Missing colon in substring qualifier for namelist variable x%m%ch(\n|\r\n|\r)" }
-! { dg-output "Substring out of range for namelist variable x%m%ch(\n|\r\n|\r)" }
-! { dg-output "Bad character in substring qualifier for namelist variable x%m%ch(\n|\r\n|\r)" }
+! { dg-output "Multiple sub-objects with non-zero rank in namelist object x%m%ch(\r*\n+)" }
+! { dg-output "Missing colon in substring qualifier for namelist variable x%m%ch(\r*\n+)" }
+! { dg-output "Substring out of range for namelist variable x%m%ch(\r*\n+)" }
+! { dg-output "Bad character in substring qualifier for namelist variable x%m%ch(\r*\n+)" }
diff --git a/gcc/testsuite/gfortran.dg/namelist_47.f90 b/gcc/testsuite/gfortran.dg/namelist_47.f90
index 2e9b424..1000aba 100644
--- a/gcc/testsuite/gfortran.dg/namelist_47.f90
+++ b/gcc/testsuite/gfortran.dg/namelist_47.f90
@@ -45,7 +45,7 @@ subroutine writenml (astring)
 end subroutine writenml
 
 end program namelist_47
-! { dg-output "Multiple sub-objects with non-zero rank in namelist object x%m%c012345678901234567890123456789012345678901234567890123456789h(\n|\r\n|\r)" }
-! { dg-output "Missing colon in substring qualifier for namelist variable x%m%c012345678901234567890123456789012345678901234567890123456789h(\n|\r\n|\r)" }
-! { dg-output "Substring out of range for namelist variable x%m%c012345678901234567890123456789012345678901234567890123456789h(\n|\r\n|\r)" }
-! { dg-output "Bad character in substring qualifier for namelist variable x%m%c012345678901234567890123456789012345678901234567890123456789h(\n|\r\n|\r)" }
+! { dg-output "Multiple sub-objects with non-zero rank in namelist object x%m%c012345678901234567890123456789012345678901234567890123456789h(\r*\n+)" }
+! { dg-output "Missing colon in substring qualifier for namelist variable x%m%c012345678901234567890123456789012345678901234567890123456789h(\r*\n+)" }
+! { dg-output "Substring out of range for namelist variable x%m%c012345678901234567890123456789012345678901234567890123456789h(\r*\n+)" }
+! { dg-output "Bad character in substring qualifier for namelist variable x%m%c012345678901234567890123456789012345678901234567890123456789h(\r*\n+)" }
diff --git a/gcc/testsuite/gfortran.dg/namelist_print_1.f b/gcc/testsuite/gfortran.dg/namelist_print_1.f
index d97d1c9..147ae50 100644
--- a/gcc/testsuite/gfortran.dg/namelist_print_1.f
+++ b/gcc/testsuite/gfortran.dg/namelist_print_1.f
@@ -9,5 +9,5 @@
       namelist /mynml/ x
       x = 1
 ! { dg-output "^" }
-      print mynml ! { dg-output "&MYNML(\n|\r\n|\r) X=  1.00000000    ,(\n|\r\n|\r) /(\n|\r\n|\r)" }
+      print mynml ! { dg-output "&MYNML(\r*\n+) X=  1.00000000    ,(\r*\n+) /(\r*\n+)" }
       end
diff --git a/gcc/testsuite/gfortran.dg/parameter_array_dummy.f90 b/gcc/testsuite/gfortran.dg/parameter_array_dummy.f90
index d9a4343..057beaa 100644
--- a/gcc/testsuite/gfortran.dg/parameter_array_dummy.f90
+++ b/gcc/testsuite/gfortran.dg/parameter_array_dummy.f90
@@ -14,8 +14,8 @@ contains
     write (*,*) i, "a" // letters(ivec)
   end subroutine concat
 end program foo_mod
-! { dg-output " *1 aa(\n|\r\n|\r)" }
-! { dg-output " *2 ab(\n|\r\n|\r)" }
-! { dg-output " *3 aaab(\n|\r\n|\r)" }
-! { dg-output " *4 abaa(\n|\r\n|\r)" }
-! { dg-output " *5 ababab(\n|\r\n|\r)" }
+! { dg-output " *1 aa(\r*\n+)" }
+! { dg-output " *2 ab(\r*\n+)" }
+! { dg-output " *3 aaab(\r*\n+)" }
+! { dg-output " *4 abaa(\r*\n+)" }
+! { dg-output " *5 ababab(\r*\n+)" }
diff --git a/gcc/testsuite/gfortran.dg/parameter_data0.f90 b/gcc/testsuite/gfortran.dg/parameter_data0.f90
new file mode 100644
index 0000000..4f1da9e
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/parameter_data0.f90
@@ -0,0 +1,6 @@
+! { dg-do compile }
+! PR fortran/102595  Similar to 88048 with a zero sized array
+program p
+   complex, parameter:: x(0) = 2
+   data x%im /3.0/ ! { dg-error "shall not appear in a DATA statement" }
+end
diff --git a/gcc/testsuite/gfortran.dg/pr103506_1.f90 b/gcc/testsuite/gfortran.dg/pr103506_1.f90
new file mode 100644
index 0000000..3f57809
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/pr103506_1.f90
@@ -0,0 +1,9 @@
+! { dg-do compile }
+! PR103506 ICE in gfc_free_namespace. ice-on-invalid
+! Test case from the PR.
+module m ! { dg-error "is already being used as a MODULE" }
+stop ! { dg-error "Unexpected STOP statement in MODULE" }
+end
+program p
+call m ! { dg-error "is already being used as a MODULE" }
+end
diff --git a/gcc/testsuite/gfortran.dg/pr108420.f90 b/gcc/testsuite/gfortran.dg/pr108420.f90
new file mode 100644
index 0000000..985c0b3
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/pr108420.f90
@@ -0,0 +1,10 @@
+! { dg-do compile }
+! PR fortran/108420
+! Contributed by G.Steinmetz
+
+program p
+  character :: c = 'c'
+  logical   :: m = .true.
+  print *, merge(transfer('a', 'b', 0), c, .true.)
+  print *, merge(transfer('a', 'b', 0), c, m)
+end
diff --git a/gcc/testsuite/gfortran.dg/pr108421.f90 b/gcc/testsuite/gfortran.dg/pr108421.f90
new file mode 100644
index 0000000..89439bc
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/pr108421.f90
@@ -0,0 +1,11 @@
+! { dg-do compile }
+! PR fortran/108421
+! Contributed by G.Steinmetz
+
+program p
+  character(real(3)) :: c ! { dg-error "must be of INTEGER type" }
+  call s(c)
+end
+subroutine s(x)
+  character(*) :: x
+end
diff --git a/gcc/testsuite/gfortran.dg/pr108434.f90 b/gcc/testsuite/gfortran.dg/pr108434.f90
new file mode 100644
index 0000000..e1768a5
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/pr108434.f90
@@ -0,0 +1,11 @@
+! { dg-do compile }
+! PR fortran/108434 - ICE in class_allocatable
+! Contributed by G.Steinmetz
+
+program p
+  type t
+     class(c), pointer :: a(2) ! { dg-error "must have a deferred shape" }
+  end type t
+  class(t), allocatable :: x
+  class(t), pointer     :: y
+end
diff --git a/gcc/testsuite/gfortran.dg/pr108501.f90 b/gcc/testsuite/gfortran.dg/pr108501.f90
new file mode 100644
index 0000000..09ab8c9
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/pr108501.f90
@@ -0,0 +1,14 @@
+! { dg-do compile }
+! PR fortran/108501 - ICE in get_expr_storage_size
+! Contributed by G.Steinmetz
+
+program p
+  real, parameter :: n = 2
+  real :: a(1,(n),2) ! { dg-error "must be of INTEGER type" }
+  call s(a(:,:,1))
+end
+subroutine s(x)
+  real :: x(2)
+end
+
+! { dg-prune-output "must have constant shape" }
diff --git a/gcc/testsuite/gfortran.dg/pr108502.f90 b/gcc/testsuite/gfortran.dg/pr108502.f90
new file mode 100644
index 0000000..45f7384
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/pr108502.f90
@@ -0,0 +1,12 @@
+! { dg-do compile }
+! { dg-options "-O2 -ffrontend-optimize" }
+! PR fortran/108502 - ICE in gfc_check_dependency
+! Contributed by G.Steinmetz
+
+integer function n()
+  integer :: a(1)
+  a = [1] / 0
+end
+program p
+  integer :: b = n() ! { dg-error "must be an intrinsic function" }
+end
diff --git a/gcc/testsuite/gfortran.dg/pr108527.f90 b/gcc/testsuite/gfortran.dg/pr108527.f90
new file mode 100644
index 0000000..c97ba31
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/pr108527.f90
@@ -0,0 +1,10 @@
+! { dg-do compile }
+! PR fortran/108527 - ICE in compare_bound_int
+! Contributed by G.Steinmetz
+
+program p
+  integer, parameter :: a((2.)) = [4,8] ! { dg-error "must be of INTEGER type" }
+  integer(a(1:1)) :: b                  ! { dg-error "out of bounds" }
+end
+
+! { dg-prune-output "Parameter array" }
diff --git a/gcc/testsuite/gfortran.dg/pr108528.f90 b/gcc/testsuite/gfortran.dg/pr108528.f90
new file mode 100644
index 0000000..7a353cb
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/pr108528.f90
@@ -0,0 +1,9 @@
+! { dg-do compile }
+! PR fortran/108528 -
+! Contributed by G.Steinmetz
+
+function f()         ! { dg-error "mismatched array specifications" }
+  integer :: f((2.)) ! { dg-error "must be of INTEGER type" }
+  integer :: g((2))
+entry g()
+end
diff --git a/gcc/testsuite/gfortran.dg/pr108529.f90 b/gcc/testsuite/gfortran.dg/pr108529.f90
new file mode 100644
index 0000000..34c9691
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/pr108529.f90
@@ -0,0 +1,9 @@
+! { dg-do compile }
+! PR fortran/108529 - ICE in transformational_result
+! Contributed by G.Steinmetz
+
+program p
+  integer, parameter :: a(*,*) = reshape([1, 2, 3, 4], [2, 2])
+  logical, parameter :: b(2,*) = a > 2     ! { dg-error "Assumed size" }
+  logical, parameter :: c(*)   = all(b, 1) ! { dg-error "Bad shape" }
+end
diff --git a/gcc/testsuite/gfortran.dg/pr108544.f90 b/gcc/testsuite/gfortran.dg/pr108544.f90
new file mode 100644
index 0000000..783cb7a
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/pr108544.f90
@@ -0,0 +1,11 @@
+! { dg-do compile }
+! PR fortran/108544 - ICE in check_host_association
+! Contributed by G.Steinmetz
+
+module m
+contains
+  subroutine s
+    select type (s => 1) ! { dg-error "Selector shall be polymorphic" }
+    end select
+  end
+end
diff --git a/gcc/testsuite/gfortran.dg/pr88048.f90 b/gcc/testsuite/gfortran.dg/pr88048.f90
index 1129393..ad82d45 100644
--- a/gcc/testsuite/gfortran.dg/pr88048.f90
+++ b/gcc/testsuite/gfortran.dg/pr88048.f90
@@ -2,6 +2,6 @@
 ! PR fortran/88048
 program p
    integer, parameter :: a(2) = 1
-   data a(2) /a(1)/                 ! { dg-error "definable entity" }
+   data a(2) /a(1)/  ! { dg-error "shall not appear in a DATA statement" }
    print *, a
 end
diff --git a/gcc/testsuite/gfortran.dg/pr96102b.f90 b/gcc/testsuite/gfortran.dg/pr96102b.f90
new file mode 100644
index 0000000..82147da
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/pr96102b.f90
@@ -0,0 +1,24 @@
+! { dg-do compile }
+!
+! PR fortran/108544 - host association
+! Variation of testcase pr96102.f90 using subroutines instead of functions
+
+module m
+  type mytype
+    integer :: i
+  end type
+  type(mytype) :: d = mytype (42) ! { dg-error "is host associated" }
+  integer      :: n = 2           ! { dg-error "is host associated" }
+contains
+  subroutine s
+    if ( n   /= 0 ) stop 1  ! { dg-error "internal procedure of the same name" }
+    if ( d%i /= 0 ) stop 2  ! { dg-error "internal procedure of the same name" }
+  contains
+    subroutine n()
+    end
+    subroutine d()
+    end
+  end
+end
+
+! { dg-prune-output "Operands of comparison operator" }
diff --git a/gcc/testsuite/gm2/case/pass/case-pass.exp b/gcc/testsuite/gm2/case/pass/case-pass.exp
index 9c7211b..e73e4b4 100644
--- a/gcc/testsuite/gm2/case/pass/case-pass.exp
+++ b/gcc/testsuite/gm2/case/pass/case-pass.exp
@@ -25,7 +25,7 @@ if $tracelevel then {
 # load support procs
 load_lib gm2-torture.exp
 
-gm2_init_pim ${srcdir}/gm2/case/pass;
+gm2_init_pim "${srcdir}/gm2/case/pass"
 
 foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/*.mod]] {
     # If we're only testing specific files and this isn't one of them, skip it.
diff --git a/gcc/testsuite/gm2/complex/pass/complex-pass.exp b/gcc/testsuite/gm2/complex/pass/complex-pass.exp
index 91d8323..a661be1 100644
--- a/gcc/testsuite/gm2/complex/pass/complex-pass.exp
+++ b/gcc/testsuite/gm2/complex/pass/complex-pass.exp
@@ -25,7 +25,7 @@ if $tracelevel then {
 # load support procs
 load_lib gm2-torture.exp
 
-gm2_init_iso
+gm2_init_iso ""
 
 foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/*.mod]] {
     # If we're only testing specific files and this isn't one of them, skip it.
diff --git a/gcc/testsuite/gm2/complex/run/pass/complex-run-pass.exp b/gcc/testsuite/gm2/complex/run/pass/complex-run-pass.exp
index a715ec2..399f30b 100644
--- a/gcc/testsuite/gm2/complex/run/pass/complex-run-pass.exp
+++ b/gcc/testsuite/gm2/complex/run/pass/complex-run-pass.exp
@@ -27,7 +27,6 @@ load_lib gm2-torture.exp
 
 set gm2src ${srcdir}/../gm2
 
-gm2_link_lib "m2iso m2pim"
 gm2_init_iso "${srcdir}/gm2/complex/run/pass"
 
 
diff --git a/gcc/testsuite/gm2/coroutines/pim/run/pass/coroutines-pim-run-pass.exp b/gcc/testsuite/gm2/coroutines/pim/run/pass/coroutines-pim-run-pass.exp
index 81580ce..92ed8d8 100644
--- a/gcc/testsuite/gm2/coroutines/pim/run/pass/coroutines-pim-run-pass.exp
+++ b/gcc/testsuite/gm2/coroutines/pim/run/pass/coroutines-pim-run-pass.exp
@@ -28,7 +28,7 @@ load_lib timeout-dg.exp
 
 set gm2src ${srcdir}/../gm2
 
-gm2_init_cor
+gm2_init_cor ""
 
 # We should be able to compile, link or run in 15 seconds.
 gm2_push_timeout 15
diff --git a/gcc/testsuite/gm2/iso/analysis/fail/iso-analysis-fail.exp b/gcc/testsuite/gm2/iso/analysis/fail/iso-analysis-fail.exp
index 7a68c80..a6c050f 100644
--- a/gcc/testsuite/gm2/iso/analysis/fail/iso-analysis-fail.exp
+++ b/gcc/testsuite/gm2/iso/analysis/fail/iso-analysis-fail.exp
@@ -24,7 +24,7 @@ if $tracelevel then {
 # load support procs
 load_lib gm2-torture.exp
 
-gm2_init_iso ${srcdir}/gm2/iso/fail:${srcdir}/gm2/iso/pass "-fsoft-check-all -O2"
+gm2_init_iso "${srcdir}/gm2/iso/fail:${srcdir}/gm2/iso/pass" "-fsoft-check-all -O2"
 
 foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/*.mod]] {
     # If we're only testing specific files and this isn't one of them, skip it.
diff --git a/gcc/testsuite/gm2/iso/check/fail/iso-check-fail.exp b/gcc/testsuite/gm2/iso/check/fail/iso-check-fail.exp
index cca7ef2..69a1fef 100644
--- a/gcc/testsuite/gm2/iso/check/fail/iso-check-fail.exp
+++ b/gcc/testsuite/gm2/iso/check/fail/iso-check-fail.exp
@@ -44,7 +44,7 @@ set TORTURE_OPTIONS [list \
 			 { -O3 -fsoft-check-all } \
 		         { -O3 -g -fsoft-check-all } ]
 
-gm2_init_iso ${srcdir}/gm2/iso/check/fail
+gm2_init_iso "${srcdir}/gm2/iso/check/fail"
 
 foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/*.mod]] {
     # If we're only testing specific files and this isn't one of them, skip it.
diff --git a/gcc/testsuite/gm2/iso/fail/iso-fail.exp b/gcc/testsuite/gm2/iso/fail/iso-fail.exp
index 19dcf31..5e442d6 100644
--- a/gcc/testsuite/gm2/iso/fail/iso-fail.exp
+++ b/gcc/testsuite/gm2/iso/fail/iso-fail.exp
@@ -24,7 +24,7 @@ if $tracelevel then {
 # load support procs
 load_lib gm2-torture.exp
 
-gm2_init_iso ${srcdir}/gm2/iso/fail:${srcdir}/gm2/iso/pass
+gm2_init_iso "${srcdir}/gm2/iso/fail ${srcdir}/gm2/iso/pass"
 
 foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/*.mod]] {
     # If we're only testing specific files and this isn't one of them, skip it.
diff --git a/gcc/testsuite/gm2/iso/pass/iso-pass.exp b/gcc/testsuite/gm2/iso/pass/iso-pass.exp
index 657e88a..24c7cd3 100644
--- a/gcc/testsuite/gm2/iso/pass/iso-pass.exp
+++ b/gcc/testsuite/gm2/iso/pass/iso-pass.exp
@@ -24,7 +24,7 @@ if $tracelevel then {
 # load support procs
 load_lib gm2-torture.exp
 
-gm2_init_iso ${srcdir}/gm2/iso/pass -fcpp;
+gm2_init_iso "${srcdir}/gm2/iso/pass" -fcpp
 
 foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/*.mod]] {
     # If we're only testing specific files and this isn't one of them, skip it.
diff --git a/gcc/testsuite/gm2/iso/run/pass/iso-run-pass.exp b/gcc/testsuite/gm2/iso/run/pass/iso-run-pass.exp
index 95b1303..09d04ee 100644
--- a/gcc/testsuite/gm2/iso/run/pass/iso-run-pass.exp
+++ b/gcc/testsuite/gm2/iso/run/pass/iso-run-pass.exp
@@ -24,7 +24,6 @@ if $tracelevel then {
 # load support procs
 load_lib gm2-torture.exp
 
-gm2_link_lib "m2iso m2pim"
 gm2_init_iso "${srcdir}/gm2/iso/run/pass" -fsoft-check-all
 gm2_link_obj fileio.o
 
diff --git a/gcc/testsuite/gm2/isolib/run/pass/isolib-run-pass.exp b/gcc/testsuite/gm2/isolib/run/pass/isolib-run-pass.exp
index 5575c50..46ab2fe 100644
--- a/gcc/testsuite/gm2/isolib/run/pass/isolib-run-pass.exp
+++ b/gcc/testsuite/gm2/isolib/run/pass/isolib-run-pass.exp
@@ -27,7 +27,7 @@ load_lib gm2-torture.exp
 
 set gm2src ${srcdir}/../gm2
 
-gm2_init_iso "-I${srcdir}/gm2/iso/run/pass"
+gm2_init_iso "${srcdir}/gm2/iso/run/pass"
 
 set cmd [exec cp $srcdir/$subdir/testinput .]
 set cmd [exec cp $srcdir/$subdir/testnumber .]
diff --git a/gcc/testsuite/gm2/link/externalscaffold/pass/link-externalscaffold-pass.exp b/gcc/testsuite/gm2/link/externalscaffold/pass/link-externalscaffold-pass.exp
index 26c9155..32d4315 100644
--- a/gcc/testsuite/gm2/link/externalscaffold/pass/link-externalscaffold-pass.exp
+++ b/gcc/testsuite/gm2/link/externalscaffold/pass/link-externalscaffold-pass.exp
@@ -25,7 +25,6 @@ if $tracelevel then {
 # load support procs
 load_lib gm2-torture.exp
 
-gm2_link_lib "m2pim"
 gm2_init_pim "${srcdir}/gm2/pim/pass" -fscaffold-main -fno-scaffold-dynamic
 gm2_link_obj scaffold.o
 set output [target_compile $srcdir/$subdir/scaffold.c scaffold.o object "-g"]
diff --git a/gcc/testsuite/gm2/pim/fail/empty.mod b/gcc/testsuite/gm2/pim/fail/empty.mod
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/gcc/testsuite/gm2/pim/fail/empty.mod
@@ -0,0 +1 @@
+
diff --git a/gcc/testsuite/gm2/pim/fail/pim-fail.exp b/gcc/testsuite/gm2/pim/fail/pim-fail.exp
index 92e82cb..febf7a3 100644
--- a/gcc/testsuite/gm2/pim/fail/pim-fail.exp
+++ b/gcc/testsuite/gm2/pim/fail/pim-fail.exp
@@ -24,7 +24,7 @@ if $tracelevel then {
 # load support procs
 load_lib gm2-torture.exp
 
-gm2_init_pim "${srcdir}/gm2/pim/fail:${srcdir}/gm2/pim/pass"
+gm2_init_pim "${srcdir}/gm2/pim/fail ${srcdir}/gm2/pim/pass"
 
 foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/*.mod]] {
     # If we're only testing specific files and this isn't one of them, skip it.
diff --git a/gcc/testsuite/gm2/pim/pass/pim-pass.exp b/gcc/testsuite/gm2/pim/pass/pim-pass.exp
index e63297e..6325edf 100644
--- a/gcc/testsuite/gm2/pim/pass/pim-pass.exp
+++ b/gcc/testsuite/gm2/pim/pass/pim-pass.exp
@@ -26,7 +26,7 @@ load_lib gm2-torture.exp
 
 set gm2src ${srcdir}/../m2
 
-gm2_init_log "${srcdir}/gm2/pim/pass:${gm2src}/gm2-compiler:${gm2src}/gm2-gcc"
+gm2_init_log "${srcdir}/gm2/pim/pass ${gm2src}/gm2-compiler ${gm2src}/gm2-gcc"
 
 foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/*.mod]] {
     # If we're only testing specific files and this isn't one of them, skip it.
diff --git a/gcc/testsuite/gm2/pimlib/logitech/run/pass/pimlib-logitech-run-pass.exp b/gcc/testsuite/gm2/pimlib/logitech/run/pass/pimlib-logitech-run-pass.exp
index 912c457..2b530a5 100644
--- a/gcc/testsuite/gm2/pimlib/logitech/run/pass/pimlib-logitech-run-pass.exp
+++ b/gcc/testsuite/gm2/pimlib/logitech/run/pass/pimlib-logitech-run-pass.exp
@@ -27,9 +27,7 @@ load_lib gm2-torture.exp
 
 set gm2src ${srcdir}/../m2
 
-gm2_link_lib "m2log m2pim m2iso"
-gm2_init_log
-
+gm2_init_log ""
 
 foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/*.mod]] {
     # If we're only testing specific files and this isn't one of them, skip it.
diff --git a/gcc/testsuite/gm2/pimlib/pass/pimlib-pass.exp b/gcc/testsuite/gm2/pimlib/pass/pimlib-pass.exp
index 22a679f..3c11646 100644
--- a/gcc/testsuite/gm2/pimlib/pass/pimlib-pass.exp
+++ b/gcc/testsuite/gm2/pimlib/pass/pimlib-pass.exp
@@ -25,7 +25,7 @@ if $tracelevel then {
 # load support procs
 load_lib gm2-torture.exp
 
-gm2_init_log
+gm2_init_log ""
 
 foreach testcase [lsort [glob -nocomplain $srcdir/../gm2/gm2-libs-pim/*.mod]] {
     # If we're only testing specific files and this isn't one of them, skip it.
diff --git a/gcc/testsuite/gm2/pimlib/run/pass/pimlib-run-pass.exp b/gcc/testsuite/gm2/pimlib/run/pass/pimlib-run-pass.exp
index 99fdb71..2b530a5 100644
--- a/gcc/testsuite/gm2/pimlib/run/pass/pimlib-run-pass.exp
+++ b/gcc/testsuite/gm2/pimlib/run/pass/pimlib-run-pass.exp
@@ -27,9 +27,7 @@ load_lib gm2-torture.exp
 
 set gm2src ${srcdir}/../m2
 
-gm2_link_lib "m2pim m2log m2iso"
-gm2_init_log
-
+gm2_init_log ""
 
 foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/*.mod]] {
     # If we're only testing specific files and this isn't one of them, skip it.
diff --git a/gcc/testsuite/gm2/projects/iso/run/pass/halma/projects-iso-run-pass-halma.exp b/gcc/testsuite/gm2/projects/iso/run/pass/halma/projects-iso-run-pass-halma.exp
index 8cb19a1..faec3f9 100644
--- a/gcc/testsuite/gm2/projects/iso/run/pass/halma/projects-iso-run-pass-halma.exp
+++ b/gcc/testsuite/gm2/projects/iso/run/pass/halma/projects-iso-run-pass-halma.exp
@@ -27,8 +27,7 @@ load_lib gm2-torture.exp
 
 set gm2src ${srcdir}/../m2
 
-gm2_link_lib "m2iso m2pim"
-gm2_init_iso
+gm2_init_iso ""
 
 foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/*.mod]] {
     # If we're only testing specific files and this isn't one of them, skip it.
diff --git a/gcc/testsuite/gm2/projects/iso/run/pass/hello/projects-iso-run-pass-hello.exp b/gcc/testsuite/gm2/projects/iso/run/pass/hello/projects-iso-run-pass-hello.exp
index 8cb19a1..faec3f9 100644
--- a/gcc/testsuite/gm2/projects/iso/run/pass/hello/projects-iso-run-pass-hello.exp
+++ b/gcc/testsuite/gm2/projects/iso/run/pass/hello/projects-iso-run-pass-hello.exp
@@ -27,8 +27,7 @@ load_lib gm2-torture.exp
 
 set gm2src ${srcdir}/../m2
 
-gm2_link_lib "m2iso m2pim"
-gm2_init_iso
+gm2_init_iso ""
 
 foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/*.mod]] {
     # If we're only testing specific files and this isn't one of them, skip it.
diff --git a/gcc/testsuite/gm2/projects/log/run/pass/hello/projects-log-run-pass-hello.exp b/gcc/testsuite/gm2/projects/log/run/pass/hello/projects-log-run-pass-hello.exp
index 36e402d..375af70 100644
--- a/gcc/testsuite/gm2/projects/log/run/pass/hello/projects-log-run-pass-hello.exp
+++ b/gcc/testsuite/gm2/projects/log/run/pass/hello/projects-log-run-pass-hello.exp
@@ -27,8 +27,7 @@ load_lib gm2-torture.exp
 
 set gm2src ${srcdir}/../m2
 
-# gm2_link_lib "m2log m2pim m2iso"
-gm2_init_log
+gm2_init_log ""
 
 foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/*.mod]] {
     # If we're only testing specific files and this isn't one of them, skip it.
diff --git a/gcc/testsuite/gm2/projects/pim/run/pass/hello/projects-pim-run-pass-hello.exp b/gcc/testsuite/gm2/projects/pim/run/pass/hello/projects-pim-run-pass-hello.exp
index 1c46f81..3e8db47 100644
--- a/gcc/testsuite/gm2/projects/pim/run/pass/hello/projects-pim-run-pass-hello.exp
+++ b/gcc/testsuite/gm2/projects/pim/run/pass/hello/projects-pim-run-pass-hello.exp
@@ -27,8 +27,7 @@ load_lib gm2-torture.exp
 
 set gm2src ${srcdir}/../m2
 
-gm2_link_lib "m2pim m2log m2iso"
-gm2_init_pim
+gm2_init_pim ""
 
 foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/*.mod]] {
     # If we're only testing specific files and this isn't one of them, skip it.
diff --git a/gcc/testsuite/gm2/projects/pim/run/pass/random/projects-pim-run-pass-random.exp b/gcc/testsuite/gm2/projects/pim/run/pass/random/projects-pim-run-pass-random.exp
index 5ae14ec..012caa6 100644
--- a/gcc/testsuite/gm2/projects/pim/run/pass/random/projects-pim-run-pass-random.exp
+++ b/gcc/testsuite/gm2/projects/pim/run/pass/random/projects-pim-run-pass-random.exp
@@ -25,27 +25,26 @@ if $tracelevel then {
 # load support procs
 load_lib gm2-torture.exp
 
-set gm2src ${srcdir}/../m2
-
-gm2_link_lib "m2pim m2log m2iso"
-gm2_init_pim "-g -I$srcdir/$subdir"
+gm2_init_pim "$srcdir/$subdir" -g
 gm2_link_obj "WriteMap.o AdvMap.o BoxMap.o Chance.o Geometry.o MakeBoxes.o MapOptions.o Options.o RoomMap.o StoreCoords.o"
 
+# If we want these to be re-built for each torture option we need some different 
+# logic.
+gm2_target_compile $srcdir/$subdir/AdvMap.mod AdvMap.o object "-g -I$srcdir/$subdir/"
+gm2_target_compile $srcdir/$subdir/BoxMap.mod BoxMap.o object "-g -I$srcdir/$subdir/"
+gm2_target_compile $srcdir/$subdir/Chance.mod Chance.o object "-g -I$srcdir/$subdir/"
+gm2_target_compile $srcdir/$subdir/Geometry.mod Geometry.o object "-g -I$srcdir/$subdir/"
+gm2_target_compile $srcdir/$subdir/MakeBoxes.mod MakeBoxes.o object "-g -I$srcdir/$subdir/"
+gm2_target_compile $srcdir/$subdir/MapOptions.mod MapOptions.o object "-g -I$srcdir/$subdir/"
+gm2_target_compile $srcdir/$subdir/Options.mod Options.o object "-g -I$srcdir/$subdir/"
+gm2_target_compile $srcdir/$subdir/RoomMap.mod RoomMap.o object "-g -I$srcdir/$subdir/"
+gm2_target_compile $srcdir/$subdir/StoreCoords.mod StoreCoords.o object "-g -I$srcdir/$subdir/"
+gm2_target_compile $srcdir/$subdir/WriteMap.mod WriteMap.o object "-g -I$srcdir/$subdir/"
+
 foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/Map.mod]] {
     # If we're only testing specific files and this isn't one of them, skip it.
     if ![runtest_file_p $runtests $testcase] then {
 	continue
     }
-
-    gm2_target_compile $srcdir/$subdir/AdvMap.mod AdvMap.o object "-g -I$srcdir/$subdir/"
-    gm2_target_compile $srcdir/$subdir/BoxMap.mod BoxMap.o object "-g -I$srcdir/$subdir/"
-    gm2_target_compile $srcdir/$subdir/Chance.mod Chance.o object "-g -I$srcdir/$subdir/"
-    gm2_target_compile $srcdir/$subdir/Geometry.mod Geometry.o object "-g -I$srcdir/$subdir/"
-    gm2_target_compile $srcdir/$subdir/MakeBoxes.mod MakeBoxes.o object "-g -I$srcdir/$subdir/"
-    gm2_target_compile $srcdir/$subdir/MapOptions.mod MapOptions.o object "-g -I$srcdir/$subdir/"
-    gm2_target_compile $srcdir/$subdir/Options.mod Options.o object "-g -I$srcdir/$subdir/"
-    gm2_target_compile $srcdir/$subdir/RoomMap.mod RoomMap.o object "-g -I$srcdir/$subdir/"
-    gm2_target_compile $srcdir/$subdir/StoreCoords.mod StoreCoords.o object "-g -I$srcdir/$subdir/"
-    gm2_target_compile $srcdir/$subdir/WriteMap.mod WriteMap.o object "-g -I$srcdir/$subdir/"
     gm2-torture-execute $testcase "" "pass"
 }
diff --git a/gcc/testsuite/gm2/recover/pass/recover-pass.exp b/gcc/testsuite/gm2/recover/pass/recover-pass.exp
index 22a679f..3c11646 100644
--- a/gcc/testsuite/gm2/recover/pass/recover-pass.exp
+++ b/gcc/testsuite/gm2/recover/pass/recover-pass.exp
@@ -25,7 +25,7 @@ if $tracelevel then {
 # load support procs
 load_lib gm2-torture.exp
 
-gm2_init_log
+gm2_init_log ""
 
 foreach testcase [lsort [glob -nocomplain $srcdir/../gm2/gm2-libs-pim/*.mod]] {
     # If we're only testing specific files and this isn't one of them, skip it.
diff --git a/gcc/testsuite/gm2/sets/run/pass/sets-run-pass.exp b/gcc/testsuite/gm2/sets/run/pass/sets-run-pass.exp
index d0cb7b0..a439526 100644
--- a/gcc/testsuite/gm2/sets/run/pass/sets-run-pass.exp
+++ b/gcc/testsuite/gm2/sets/run/pass/sets-run-pass.exp
@@ -27,7 +27,6 @@ load_lib gm2-torture.exp
 
 set gm2src ${srcdir}/../m2
 
-gm2_link_lib "m2iso m2pim"
 gm2_init_iso "${srcdir}/gm2/sets/run/pass/"
 
 foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/*.mod]] {
diff --git a/gcc/testsuite/gm2/switches/makeall/fail/switches-makeall-fail.exp b/gcc/testsuite/gm2/switches/makeall/fail/switches-makeall-fail.exp
index 91787df..32da0ec 100644
--- a/gcc/testsuite/gm2/switches/makeall/fail/switches-makeall-fail.exp
+++ b/gcc/testsuite/gm2/switches/makeall/fail/switches-makeall-fail.exp
@@ -29,7 +29,7 @@ load_lib gm2-torture.exp
 #  attempts to use gm2 -fmakeall to build a syntactally incorrect program.
 #
 
-gm2_init "-I$srcdir/../gm2/gm2-libs:$srcdir/gm2/switches/makeall/fail -fmakeall"
+gm2_init "$srcdir/../gm2/gm2-libs $srcdir/gm2/switches/makeall/fail" -fmakeall
 
 
 foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/*.mod]] {
diff --git a/gcc/testsuite/gm2/switches/makeall/pass/switches-makeall-pass.exp b/gcc/testsuite/gm2/switches/makeall/pass/switches-makeall-pass.exp
index 7b6d82f..41308af 100644
--- a/gcc/testsuite/gm2/switches/makeall/pass/switches-makeall-pass.exp
+++ b/gcc/testsuite/gm2/switches/makeall/pass/switches-makeall-pass.exp
@@ -24,7 +24,7 @@ if $tracelevel then {
 # load support procs
 load_lib gm2-torture.exp
 
-gm2_init "-I${srcdir}/gm2/switches/makeall/pass" -fmakeall
+gm2_init "${srcdir}/gm2/switches/makeall/pass" -fmakeall
 gm2_init_pim4 "${srcdir}/gm2/switches/makeall/pass"
 
 foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/*.mod]] {
diff --git a/gcc/testsuite/gm2/switches/none/run/pass/gm2-none.exp b/gcc/testsuite/gm2/switches/none/run/pass/gm2-none.exp
index 747c474..86dab20 100644
--- a/gcc/testsuite/gm2/switches/none/run/pass/gm2-none.exp
+++ b/gcc/testsuite/gm2/switches/none/run/pass/gm2-none.exp
@@ -26,8 +26,7 @@ load_lib gm2-simple.exp
 
 set gm2src ${srcdir}/../m2
 
-gm2_link_lib "m2pim m2iso"
-gm2_init_pim
+gm2_init_pim ""
 
 foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/*.mod]] {
     # If we're only testing specific files and this isn't one of them, skip it.
diff --git a/gcc/testsuite/gm2/switches/pic/run/pass/switches-pic-run-pass.exp b/gcc/testsuite/gm2/switches/pic/run/pass/switches-pic-run-pass.exp
index a2af765..67ee502 100644
--- a/gcc/testsuite/gm2/switches/pic/run/pass/switches-pic-run-pass.exp
+++ b/gcc/testsuite/gm2/switches/pic/run/pass/switches-pic-run-pass.exp
@@ -26,10 +26,8 @@ load_lib gm2-torture.exp
 
 set gm2src ${srcdir}/../m2
 
-gm2_link_lib "m2pim m2iso"
 gm2_init_pim "${srcdir}/gm2/switches/pic/run/pass" -fPIC
 
-
 foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/*.mod]] {
     # If we're only testing specific files and this isn't one of them, skip it.
     if ![runtest_file_p $runtests $testcase] then {
diff --git a/gcc/testsuite/gm2/switches/pim2/run/pass/switches-pim2-run-pass.exp b/gcc/testsuite/gm2/switches/pim2/run/pass/switches-pim2-run-pass.exp
index 135a3d6..04a32c6 100644
--- a/gcc/testsuite/gm2/switches/pim2/run/pass/switches-pim2-run-pass.exp
+++ b/gcc/testsuite/gm2/switches/pim2/run/pass/switches-pim2-run-pass.exp
@@ -27,7 +27,7 @@ load_lib gm2-torture.exp
 
 set gm2src ${srcdir}/../m2
 
-gm2_init_pim2
+gm2_init_pim2 ""
 
 foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/*.mod]] {
     # If we're only testing specific files and this isn't one of them, skip it.
diff --git a/gcc/testsuite/gm2/ulmlib/pass/ulmlib-pass.exp b/gcc/testsuite/gm2/ulmlib/pass/ulmlib-pass.exp
index 0bda866..0e17dde 100644
--- a/gcc/testsuite/gm2/ulmlib/pass/ulmlib-pass.exp
+++ b/gcc/testsuite/gm2/ulmlib/pass/ulmlib-pass.exp
@@ -25,7 +25,7 @@ if $tracelevel then {
 # load support procs
 load_lib gm2-torture.exp
 
-gm2_init_ulm
+gm2_init_ulm ""
 
 foreach testcase [lsort [glob -nocomplain $srcdir/../gm2/ulm-lib-gm2/sys/*.mod]] {
     # If we're only testing specific files and this isn't one of them, skip it.
diff --git a/gcc/testsuite/gm2/ulmlib/std/pass/ulmlib-std-pass.exp b/gcc/testsuite/gm2/ulmlib/std/pass/ulmlib-std-pass.exp
index be01029..8aea107 100644
--- a/gcc/testsuite/gm2/ulmlib/std/pass/ulmlib-std-pass.exp
+++ b/gcc/testsuite/gm2/ulmlib/std/pass/ulmlib-std-pass.exp
@@ -25,7 +25,7 @@ if $tracelevel then {
 # load support procs
 load_lib gm2-torture.exp
 
-gm2_init_ulm
+gm2_init_ulm ""
 
 foreach testcase [lsort [glob -nocomplain $srcdir/../gm2/ulm-lib-gm2/std/*.mod]] {
     # If we're only testing specific files and this isn't one of them, skip it.
diff --git a/gcc/testsuite/gm2/ulmlib/sys/pass/ulmlib-sys-pass.exp b/gcc/testsuite/gm2/ulmlib/sys/pass/ulmlib-sys-pass.exp
index 0bda866..0e17dde 100644
--- a/gcc/testsuite/gm2/ulmlib/sys/pass/ulmlib-sys-pass.exp
+++ b/gcc/testsuite/gm2/ulmlib/sys/pass/ulmlib-sys-pass.exp
@@ -25,7 +25,7 @@ if $tracelevel then {
 # load support procs
 load_lib gm2-torture.exp
 
-gm2_init_ulm
+gm2_init_ulm ""
 
 foreach testcase [lsort [glob -nocomplain $srcdir/../gm2/ulm-lib-gm2/sys/*.mod]] {
     # If we're only testing specific files and this isn't one of them, skip it.
diff --git a/gcc/testsuite/gm2/warnings/returntype/fail/badreturn.mod b/gcc/testsuite/gm2/warnings/returntype/fail/badreturn.mod
new file mode 100644
index 0000000..af7fd81
--- /dev/null
+++ b/gcc/testsuite/gm2/warnings/returntype/fail/badreturn.mod
@@ -0,0 +1,11 @@
+MODULE badreturn ;
+
+PROCEDURE X (VAR Y : BOOLEAN) : BOOLEAN;
+BEGIN
+  IF Y
+  THEN
+    RETURN FALSE
+  END
+END X ;
+
+END badreturn.
diff --git a/gcc/testsuite/gm2/warnings/returntype/fail/warnings-returntype-fail.exp b/gcc/testsuite/gm2/warnings/returntype/fail/warnings-returntype-fail.exp
new file mode 100644
index 0000000..43e97ba
--- /dev/null
+++ b/gcc/testsuite/gm2/warnings/returntype/fail/warnings-returntype-fail.exp
@@ -0,0 +1,44 @@
+# Expect driver script for GCC Regression Tests
+# Copyright (C) 2003-2023 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with GCC; see the file COPYING3.  If not see
+# <http://www.gnu.org/licenses/>.
+
+# This file was written by Gaius Mulley (gaius.mulley@southwales.ac.uk)
+# for GNU Modula-2.
+
+if $tracelevel then {
+    strace $tracelevel
+}
+
+# load support procs
+load_lib gm2-torture.exp
+
+gm2_init_pim "${srcdir}/gm2/warnings/returntype/fail"
+
+global TORTURE_OPTIONS
+
+set old_options $TORTURE_OPTIONS
+set TORTURE_OPTIONS { { -O0 -g -Werror=return-type } }
+
+foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/*.mod]] {
+    # If we're only testing specific files and this isn't one of them, skip it.
+    if ![runtest_file_p $runtests $testcase] then {
+	continue
+    }
+
+    gm2-torture-fail $testcase
+}
+
+set TORTURE_OPTIONS $old_options
diff --git a/gcc/testsuite/gm2/warnings/returntype/pass/Termbase.mod b/gcc/testsuite/gm2/warnings/returntype/pass/Termbase.mod
new file mode 100644
index 0000000..0b47826
--- /dev/null
+++ b/gcc/testsuite/gm2/warnings/returntype/pass/Termbase.mod
@@ -0,0 +1,220 @@
+(* Termbase.mod provides GNU Modula-2 with a PIM 234 compatible Termbase.
+
+Copyright (C) 2004-2023 Free Software Foundation, Inc.
+Contributed by Gaius Mulley <gaius.mulley@southwales.ac.uk>.
+
+This file is part of GNU Modula-2.
+
+GNU Modula-2 is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 3, or (at your option)
+any later version.
+
+GNU Modula-2 is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+<http://www.gnu.org/licenses/>.  *)
+
+IMPLEMENTATION MODULE Termbase ;
+
+FROM Storage IMPORT ALLOCATE, DEALLOCATE ;
+FROM M2RTS IMPORT Halt ;
+IMPORT Display, Keyboard ;
+
+TYPE
+   ReadMethods = POINTER TO RECORD
+                               r   : ReadProcedure ;
+                               s   : StatusProcedure ;
+                               next: ReadMethods ;
+                            END ;
+
+   WriteMethod = POINTER TO RECORD
+                               w   : WriteProcedure ;
+                               next: WriteMethod ;
+                            END ;
+
+VAR
+   rStack: ReadMethods ;
+   wStack: WriteMethod ;
+
+
+(*
+   AssignRead - assigns a read procedure and status procedure for terminal
+                input. Done is set to TRUE if successful. Subsequent
+                Read and KeyPressed calls are mapped onto the user supplied
+                procedures. The previous read and status procedures are
+                uncovered and reused after UnAssignRead is called.
+*)
+
+PROCEDURE AssignRead (rp: ReadProcedure; sp: StatusProcedure;
+                      VAR Done: BOOLEAN) ;
+VAR
+   t: ReadMethods ;
+BEGIN
+   t := rStack ;
+   NEW(rStack) ;
+   IF rStack=NIL
+   THEN
+      Done := FALSE
+   ELSE
+      WITH rStack^ DO
+         r := rp ;
+         s := sp ;
+         next := t
+      END ;
+      Done := TRUE
+   END
+END AssignRead ;
+
+
+(*
+   UnAssignRead - undo the last call to AssignRead and set Done to TRUE
+                  on success.
+*)
+
+PROCEDURE UnAssignRead (VAR Done: BOOLEAN) ;
+VAR
+   t: ReadMethods ;
+BEGIN
+   IF rStack=NIL
+   THEN
+      Done := FALSE
+   ELSE
+      Done := TRUE
+   END ;
+   t := rStack ;
+   rStack := rStack^.next ;
+   DISPOSE(t)
+END UnAssignRead ;
+
+
+(*
+   Read - reads a single character using the currently active read
+          procedure.
+*)
+
+PROCEDURE Read (VAR ch: CHAR) ;
+BEGIN
+   IF rStack=NIL
+   THEN
+      Halt(__FILE__, __LINE__, __FUNCTION__, 'no active read procedure')
+   ELSE
+      rStack^.r(ch)
+   END
+END Read ;
+
+
+(*
+   KeyPressed - returns TRUE if a character is available to be read.
+*)
+
+PROCEDURE KeyPressed () : BOOLEAN ;
+BEGIN
+   IF rStack=NIL
+   THEN
+      Halt(__FILE__, __LINE__, __FUNCTION__, 'no active status procedure')
+   ELSE
+      RETURN( rStack^.s() )
+   END
+END KeyPressed ;
+
+
+(*
+   AssignWrite - assigns a write procedure for terminal output.
+                 Done is set to TRUE if successful. Subsequent
+                 Write calls are mapped onto the user supplied
+                 procedure. The previous write procedure is
+                 uncovered and reused after UnAssignWrite is called.
+*)
+
+PROCEDURE AssignWrite (wp: WriteProcedure; VAR Done: BOOLEAN) ;
+VAR
+   t: WriteMethod ;
+BEGIN
+   t := wStack ;
+   NEW(wStack) ;
+   IF wStack=NIL
+   THEN
+      Done := FALSE
+   ELSE
+      WITH wStack^ DO
+         w := wp ;
+         next := t
+      END ;
+      Done := TRUE
+   END
+END AssignWrite ;
+
+
+(*
+   UnAssignWrite - undo the last call to AssignWrite and set Done to TRUE
+                   on success.
+*)
+
+PROCEDURE UnAssignWrite (VAR Done: BOOLEAN) ;
+VAR
+   t: WriteMethod ;
+BEGIN
+   IF wStack=NIL
+   THEN
+      Done := FALSE
+   ELSE
+      Done := TRUE
+   END ;
+   t := wStack ;
+   wStack := wStack^.next ;
+   DISPOSE(t)
+END UnAssignWrite ;
+
+
+(*
+   Write - writes a single character using the currently active write
+           procedure.
+*)
+
+PROCEDURE Write (VAR ch: CHAR) ;
+BEGIN
+   IF wStack=NIL
+   THEN
+      Halt(__FILE__, __LINE__, __FUNCTION__, 'no active write procedure')
+   ELSE
+      wStack^.w(ch)
+   END
+END Write ;
+
+
+(*
+   Init -
+*)
+
+PROCEDURE Init ;
+VAR
+   Done: BOOLEAN ;
+BEGIN
+   rStack := NIL ;
+   wStack := NIL ;
+   AssignRead(Keyboard.Read, Keyboard.KeyPressed, Done) ;
+   IF NOT Done
+   THEN
+      Halt(__FILE__, __LINE__, __FUNCTION__, 'failed to assign read routines from module Keyboard')
+   END ;
+   AssignWrite(Display.Write, Done) ;
+   IF NOT Done
+   THEN
+      Halt(__FILE__, __LINE__, __FUNCTION__, 'failed to assign write routine from module Display')
+   END
+END Init ;
+
+
+BEGIN
+   Init
+END Termbase.
diff --git a/gcc/testsuite/gm2/warnings/returntype/pass/goodreturn.mod b/gcc/testsuite/gm2/warnings/returntype/pass/goodreturn.mod
new file mode 100644
index 0000000..7b27949
--- /dev/null
+++ b/gcc/testsuite/gm2/warnings/returntype/pass/goodreturn.mod
@@ -0,0 +1,13 @@
+MODULE goodreturn ;
+
+PROCEDURE X (VAR Y : BOOLEAN) : BOOLEAN;
+BEGIN
+  IF Y
+  THEN
+    RETURN FALSE
+  ELSE
+    RETURN TRUE
+  END
+END X ;
+
+END goodreturn.
diff --git a/gcc/testsuite/gm2/warnings/returntype/pass/keypressedsimple.mod b/gcc/testsuite/gm2/warnings/returntype/pass/keypressedsimple.mod
new file mode 100644
index 0000000..30d5347
--- /dev/null
+++ b/gcc/testsuite/gm2/warnings/returntype/pass/keypressedsimple.mod
@@ -0,0 +1,21 @@
+MODULE keypressedsimple ;
+
+FROM M2RTS IMPORT Halt ;
+FROM Args IMPORT Narg ;
+
+PROCEDURE KeyPressed () : BOOLEAN ;
+BEGIN
+   IF Narg () < 0
+   THEN
+      Halt(__FILE__, __LINE__, __FUNCTION__, 'no active status procedure')
+   ELSE
+      RETURN FALSE
+   END
+END KeyPressed ;
+
+
+BEGIN
+   IF KeyPressed ()
+   THEN
+   END
+END keypressedsimple.
diff --git a/gcc/testsuite/gm2/warnings/returntype/pass/warnings-returntype-pass.exp b/gcc/testsuite/gm2/warnings/returntype/pass/warnings-returntype-pass.exp
new file mode 100644
index 0000000..1cde1ae
--- /dev/null
+++ b/gcc/testsuite/gm2/warnings/returntype/pass/warnings-returntype-pass.exp
@@ -0,0 +1,38 @@
+# Copyright (C) 2003-2023 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with GCC; see the file COPYING3.  If not see
+# <http://www.gnu.org/licenses/>.
+
+# This file was written by Gaius Mulley (gaiusmod2@gmail.com)
+# for GNU Modula-2.
+
+if $tracelevel then {
+    strace $tracelevel
+}
+
+# load support procs
+load_lib gm2-torture.exp
+
+set gm2src ${srcdir}/../m2
+
+gm2_init_pim "${srcdir}/gm2/warnings/returntype/pass" -Werror=return-type
+
+foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/*.mod]] {
+    # If we're only testing specific files and this isn't one of them, skip it.
+    if ![runtest_file_p $runtests $testcase] then {
+	continue
+    }
+
+    gm2-torture $testcase
+}
diff --git a/gcc/testsuite/lib/gm2.exp b/gcc/testsuite/lib/gm2.exp
index 1e93d6a..7f41e19 100644
--- a/gcc/testsuite/lib/gm2.exp
+++ b/gcc/testsuite/lib/gm2.exp
@@ -65,22 +65,22 @@ proc gm2_pop_timeout { } {
 proc default_gcc_version { } {
     global GCC_UNDER_TEST
 
-    gm2_init;
+    gm2_init
 
     # ignore any arguments after the command
     set compiler [lindex $GCC_UNDER_TEST 0]
 
     if ![is_remote host] {
-	set compiler_name [which $compiler];
+	set compiler_name [which $compiler]
     } else {
-	set compiler_name $compiler;
+	set compiler_name $compiler
     }
 
     # verify that the compiler exists
     if { $compiler_name != 0 } then {
 	set tmp [remote_exec host "$compiler --version"]
-	set status [lindex $tmp 0];
-	set output [lindex $tmp 1];
+	set status [lindex $tmp 0]
+	set output [lindex $tmp 1]
 	regexp "version.*$" $output version
 	if { $status == 0 && [info exists version] } then {
 	    clone_output "$compiler_name $version\n"
@@ -98,7 +98,7 @@ proc default_gcc_version { } {
 #
 
 proc gcc_version { } {
-    default_gcc_version;
+    default_gcc_version
 }
 
 #
@@ -108,64 +108,64 @@ proc gcc_version { } {
 # make some enhancements without having to go back and rewrite the scripts.
 #
 
-set gm2_initialized 0;
-set gm2_compile_method "default";
-set gm2_link_path "";
-set gm2_link_libraries "m2pim m2iso";
-set gm2_link_objects "";
+set gm2_initialized 0
+set gm2_compile_method "default"
+set gm2_link_path ""
+set gm2_link_libraries "m2pim m2iso"
+set gm2_link_objects ""
 
 proc gm2_set_compile_method { arg } {
-    global gm2_compile_method;
+    global gm2_compile_method
 
     send_log "********************************************\n"
     send_log "**** setting gm2_compile_method to $arg ****\n"
     send_log "********************************************\n"
-    set gm2_compile_method $arg;
+    set gm2_compile_method $arg
 }
 
 
 proc gm2_init { args } {
-    global tmpdir;
-    global objdir;
-    global rootme;
-    global base_dir;
-    global tool_root_dir;
-    global gluefile wrap_flags;
-    global gm2_initialized;
-    global GCC_UNDER_TEST;
-    global TOOL_EXECUTABLE;
-    global gm2_link_libraries;
-    global gm2_link_objects;
-    global gm2_link_path;
-    global HAVE_LIBSTDCXX_V3;
-
-    if { $gm2_initialized == 1 } { return; }
-
-    set gm2_link_objects "";
-    set GCC_UNDER_TEST [lookfor_file $rootme gm2];
-    append GCC_UNDER_TEST " " -B[file dirname $rootme]/gcc " " ${args};
+    global tmpdir
+    global objdir
+    global rootme
+    global base_dir
+    global tool_root_dir
+    global gluefile wrap_flags
+    global gm2_initialized
+    global GCC_UNDER_TEST
+    global TOOL_EXECUTABLE
+    global gm2_link_libraries
+    global gm2_link_objects
+    global gm2_link_path
+    global HAVE_LIBSTDCXX_V3
+
+    if { $gm2_initialized == 1 } { return }
+
+    set gm2_link_objects ""
+    set GCC_UNDER_TEST [lookfor_file $rootme gm2]
+    append GCC_UNDER_TEST " " -B[file dirname $rootme]/gcc " " ${args}
     append GCC_UNDER_TEST " " -fno-diagnostics-show-caret
     append GCC_UNDER_TEST " " -fno-diagnostics-show-line-numbers
     append GCC_UNDER_TEST " " -fdiagnostics-color=never
     send_log "GCC_UNDER_TEST is ${GCC_UNDER_TEST}\n"
 
     if ![info exists tmpdir] then {
-	set tmpdir /tmp;
+	set tmpdir /tmp
     }
     if {[target_info needs_status_wrapper] != "" && \
 	    [target_info needs_status_wrapper] != "0" && \
 	    ![info exists gluefile]} {
-	set gluefile ${tmpdir}/gcc-testglue.o;
-	set result [build_wrapper $gluefile];
+	set gluefile ${tmpdir}/gcc-testglue.o
+	set result [build_wrapper $gluefile]
 	if { $result != "" } {
-	    set gluefile [lindex $result 0];
-	    set wrap_flags [lindex $result 1];
+	    set gluefile [lindex $result 0]
+	    set wrap_flags [lindex $result 1]
 	} else {
 	    unset gluefile
 	}
     }
 
-    set gm2_link_path "[gm2_link_flags [get_multilibs]]";
+    set gm2_link_path "[gm2_link_flags [get_multilibs]]"
     verbose $gm2_link_path 1
 
     # Set the default timeout value, larger tests can override
@@ -231,7 +231,7 @@ proc gm2_target_compile_default { source dest type options } {
 #
 
 proc gm2_target_compile { source dest type options } {
-    global gm2_compile_method;
+    global gm2_compile_method
 
     return [gm2_target_compile_${gm2_compile_method} $source $dest $type $options]
 }
@@ -242,9 +242,9 @@ proc gm2_target_compile { source dest type options } {
 #
 
 proc gm2_link_lib { libraries } {
-    global gm2_link_libraries;
+    global gm2_link_libraries
 
-    set gm2_link_libraries $libraries;
+    set gm2_link_libraries $libraries
 }
 
 
@@ -253,9 +253,9 @@ proc gm2_link_lib { libraries } {
 #
 
 proc gm2_link_obj { objects } {
-    global gm2_link_objects;
+    global gm2_link_objects
 
-    set gm2_link_objects $objects;
+    set gm2_link_objects $objects
 }
 
 
@@ -264,10 +264,10 @@ proc gm2_link_obj { objects } {
 #
 
 proc gm2_link_flags { paths } {
-    global srcdir;
-    global ld_library_path;
-    global gccpath;
-    global gm2_link_libraries;
+    global srcdir
+    global ld_library_path
+    global gccpath
+    global gm2_link_libraries
 
     set gccpath ${paths}
     set libio_dir ""
@@ -329,30 +329,37 @@ proc gm2_link_flags { paths } {
 #
 #
 
-proc gm2_init_pimx { dialect {path ""} args } {
-    global srcdir;
-    global gccpath;
+proc gm2_init_pimx { dialect paths args } {
+    global srcdir
+    global gccpath
+
+    set gm2src ${srcdir}/../m2
 
-    set gm2src ${srcdir}/../m2;
 
     send_log "srcdir is $srcdir\n"
     send_log "gccpath is $gccpath\n"
     send_log "gm2src is $gm2src\n"
 
-    set pimIpath "${gccpath}/libgm2/libm2pim:${gm2src}/gm2-libs";
-    set pimLpath "${gccpath}/libgm2/libm2pim/.libs";
+    set theIpath -I${gccpath}/libgm2/libm2pim
+    lappend theIpath -I${gm2src}/gm2-libs-log
 
-    set isoIpath "${gccpath}/libgm2/libm2iso:${gm2src}/gm2-libs-iso";
-    set isoLpath "${gccpath}/libgm2/libm2iso/.libs";
+    # NOTE:
+    lappend theIpath -I${gm2src}/gm2-libs
 
-    set theIpath "-I${pimIpath} -I${isoIpath}";
-    set theLpath "-L${pimLpath} -L${isoLpath}";
+    set theLpath -L${gccpath}/libgm2/libm2pim/.libs
 
-    if { $path != "" } then {
-	append theIpath " -I"
-	append theIpath ${path}
+    lappend theIpath -I${gccpath}/libgm2/libm2iso
+    lappend theIpath -I${gm2src}/gm2-libs-iso
+
+    lappend theLpath -L${gccpath}/libgm2/libm2iso/.libs
+
+    foreach p $paths {
+	lappend theIpath -I$p
     }
-    gm2_init {*}${theIpath} {*}${dialect} {*}${theLpath} {*}${args};
+
+    gm2_link_lib "m2pim m2iso"
+    lappend args -fno-libs=-
+    gm2_init {*}${theIpath} {*}${dialect} {*}${theLpath} {*}${args}
 }
 
 #
@@ -360,8 +367,8 @@ proc gm2_init_pimx { dialect {path ""} args } {
 #
 #
 
-proc gm2_init_pim { {path ""} args } {
-    gm2_init_pimx -fpim {*}${path} {*}${args};
+proc gm2_init_pim { paths args } {
+    gm2_init_pimx -fpim $paths {*}${args}
 }
 
 
@@ -370,8 +377,8 @@ proc gm2_init_pim { {path ""} args } {
 #                  It uses the PIM2 dialect.
 #
 
-proc gm2_init_pim2 { {path ""} args } {
-    gm2_init_pimx -fpim2 {*}${path} {*}${args};
+proc gm2_init_pim2 { paths args } {
+    gm2_init_pimx -fpim2 $paths {*}${args}
 }
 
 
@@ -380,8 +387,8 @@ proc gm2_init_pim2 { {path ""} args } {
 #                  It uses the PIM3 dialect.
 #
 
-proc gm2_init_pim3 { {path ""} args } {
-    gm2_init_pimx -fpim3 {*}${path} {*}${args};
+proc gm2_init_pim3 { paths args } {
+    gm2_init_pimx -fpim3 $paths {*}${args}
 }
 
 
@@ -390,8 +397,8 @@ proc gm2_init_pim3 { {path ""} args } {
 #                  It uses the PIM4 dialect.
 #
 
-proc gm2_init_pim4 { {path ""} args } {
-    gm2_init_pimx -fpim4 {*}${path} {*}${args};
+proc gm2_init_pim4 { paths args } {
+    gm2_init_pimx -fpim4 $paths {*}${args}
 }
 
 
@@ -399,58 +406,70 @@ proc gm2_init_pim4 { {path ""} args } {
 #  gm2_init_iso - set the default libraries to choose ISO and then PIM.
 #
 
-proc gm2_init_iso { {path ""} args } {
-    global srcdir;
-    global gccpath;
+proc gm2_init_iso { paths args } {
+    global srcdir
+    global gccpath
 
-    set gm2src ${srcdir}/../m2;
+    set gm2src ${srcdir}/../m2
 
-    set isoIpath "${gccpath}/libgm2/libm2iso:${gm2src}/gm2-libs-iso";
-    set pimIpath "${gccpath}/libgm2/libm2pim:${gm2src}/gm2-libs";
+    set theIpath -I${gccpath}/libgm2/libm2iso
+    lappend theIpath -I${gm2src}/gm2-libs-iso
 
-    set isoLpath "${gccpath}/libgm2/libm2iso/.libs";
-    set pimLpath "${gccpath}/libgm2/libm2pim/.libs";
+    set theLpath -L${gccpath}/libgm2/libm2iso/.libs
 
-    set corIpath "${gccpath}/libgm2/libm2cor:${gm2src}/gm2-libs-coroutines";
-    set corLpath "${gccpath}/libgm2/libm2cor/.libs";
+    lappend theIpath -I${gccpath}/libgm2/libm2pim
+    lappend theIpath -I${gm2src}/gm2-libs-log
 
-    set theIpath "-I${isoIpath} -I${corIpath} -I${pimIpath}";
-    set theLpath "-L${isoLpath} -L${corLpath} -L${pimLpath}";
+    # NOTE:
+    lappend theIpath -I${gm2src}/gm2-libs
 
-    if { $path != "" } then {
-	append theIpath " -I"
-	append theIpath ${path}
+    lappend theLpath -L${gccpath}/libgm2/libm2pim/.libs
+
+    lappend theIpath -I${gccpath}/libgm2/libm2cor
+    lappend theIpath -I${gm2src}/gm2-libs-coroutines
+
+    lappend theLpath -L${gccpath}/libgm2/libm2cor/.libs
+
+    foreach p $paths {
+	lappend theIpath -I$p
     }
 
-    gm2_init {*}${theIpath} -fiso {*}${theLpath} {*}${args};
+    gm2_link_lib "m2iso m2pim m2cor"
+    lappend args -fno-libs=-
+    gm2_init {*}${theIpath} -fiso {*}${theLpath} {*}${args}
 }
 
-
 #
 #  gm2_init_ulm - set the default libraries to choose the ULM and PIM libraries.
 #
 
-proc gm2_init_ulm { {path ""} args } {
-    global srcdir;
-    global gccpath;
+proc gm2_init_ulm { paths args } {
+    global srcdir
+    global gccpath
 
-    set gm2src ${srcdir}/../m2;
+    set gm2src ${srcdir}/../m2
 
-    set ulmIpath "${gccpath}/libgm2/libm2ulm:${gm2src}/ulm-lib-gm2/std:${gm2src}/ulm-lib-gm2/sys";
-    set ulmLpath "${gccpath}/libgm2/libm2ulm/.libs";
+    set theIpath -I${gccpath}/libgm2/libm2ulm
+    lappend theIpath -I${gm2src}/ulm-lib-gm2/std
+    lappend theIpath -I${gm2src}/ulm-lib-gm2/sys
 
-    set pimIpath "${gccpath}/libgm2/libm2pim:${gm2src}/gm2-libs";
-    set pimLpath "${gccpath}/libgm2/libm2pim/.libs";
+    set theLpath -L${gccpath}/libgm2/libm2ulm/.libs
 
-    set theIpath "-I${ulmIpath} -I${pimIpath}";
-    set theLpath "-L${ulmLpath} -L${pimLpath}";
+    lappend theIpath -I${gccpath}/libgm2/libm2pim
+    lappend theIpath -I${gm2src}/gm2-libs-log
 
-    if { $path != "" } then {
-	append theIpath " -I"
-	append theIpath ${path}
+    # NOTE:
+    lappend theIpath -I${gm2src}/gm2-libs
+
+    lappend theLpath -L${gccpath}/libgm2/libm2pim/.libs
+
+    foreach p $paths {
+	lappend theIpath -I$p
     }
 
-    gm2_init {*}${theIpath} -fpim {*}${theLpath} {*}${args};
+    gm2_link_lib "m2ulm m2pim"
+    lappend args -fno-libs=-
+    gm2_init {*}${theIpath} -fpim {*}${theLpath} {*}${args}
 }
 
 
@@ -459,35 +478,40 @@ proc gm2_init_ulm { {path ""} args } {
 #
 #
 
-proc gm2_init_log { {path ""} args } {
-    global srcdir;
-    global gccpath;
+proc gm2_init_log { paths args } {
+    global srcdir
+    global gccpath
 
-    set gm2src ${srcdir}/../m2;
+    set gm2src ${srcdir}/../m2
 
     send_log "srcdir is $srcdir\n"
     send_log "gccpath is $gccpath\n"
     send_log "gm2src is $gm2src\n"
 
-    set logIpath "${gccpath}/libgm2/libm2log:${gm2src}/gm2-libs-pim";
-    set logLpath "${gccpath}/libgm2/libm2log/.libs";
+    # FIXME: this seems to interleave the library defs.
+    set theIpath -I${gccpath}/libgm2/libm2log
+    lappend theIpath -I${gm2src}/gm2-libs-log
+
+    set theLpath -L${gccpath}/libgm2/libm2log/.libs
 
-    set pimIpath "${gccpath}/libgm2/libm2pim:${gm2src}/gm2-libs";
-    set pimLpath "${gccpath}/libgm2/libm2pim/.libs";
+    lappend theIpath -I${gccpath}/libgm2/libm2pim
+    lappend theIpath -I${gm2src}/gm2-libs
 
-    set isoIpath "${gccpath}/libgm2/libm2iso:${gm2src}/gm2-libs-iso";
-    set pimIpath "${gccpath}/libgm2/libm2pim:${gm2src}/gm2-libs";
+    lappend theLpath -L${gccpath}/libgm2/libm2pim/.libs
 
-    set theIpath "-I${logIpath} -I${pimIpath} -I${isoIpath}";
-    set theLpath "-L${logLpath} -L${pimLpath}";
+    lappend theIpath -I${gccpath}/libgm2/libm2iso
+    lappend theIpath -I${gm2src}/gm2-libs-iso
+    # ??? lappend theIpath -I${gm2src}/gm2-libs
 
-    if { $path != "" } then {
-	append theIpath " -I"
-	append theIpath ${path}
+    lappend theLpath -L${gccpath}/libgm2/libm2iso/.libs
+
+    foreach p $paths {
+	lappend theIpath -I$p
     }
 
     gm2_link_lib "m2log m2pim m2iso"
-    gm2_init {*}${theIpath} -fpim {*}${theLpath} {*}${args};
+    lappend args -fno-libs=-
+    gm2_init {*}${theIpath} -fpim {*}${theLpath} {*}${args}
 }
 
 #
@@ -495,39 +519,44 @@ proc gm2_init_log { {path ""} args } {
 #
 #
 
-proc gm2_init_cor { {path ""} args } {
-    global srcdir;
-    global gccpath;
-    global gm2_link_libraries;
+proc gm2_init_cor { paths args } {
+    global srcdir
+    global gccpath
+    global gm2_link_libraries
 
-    set gm2src ${srcdir}/../m2;
+    set gm2src ${srcdir}/../m2
 
     send_log "srcdir is $srcdir\n"
     send_log "gccpath is $gccpath\n"
     send_log "gm2src is $gm2src\n"
 
-    set corIpath "${gccpath}/libgm2/libm2cor:${gm2src}/gm2-libs-coroutines";
-    set corLpath "${gccpath}/libgm2/libm2cor/.libs";
+    set theIpath -I${gccpath}/libgm2/libm2cor
+    lappend theIpath -I${gm2src}/gm2-libs-coroutines
+
+    set theLpath -L${gccpath}/libgm2/libm2cor/.libs
+
+    lappend theIpath -I${gccpath}/libgm2/libm2pim
+    lappend theIpath -I${gm2src}/gm2-libs-log
 
-    set pimIpath "${gccpath}/libgm2/libm2pim:${gm2src}/gm2-libs";
-    set pimLpath "${gccpath}/libgm2/libm2pim/.libs";
+    lappend theLpath -L${gccpath}/libgm2/libm2pim/.libs
 
-    set isoIpath "${gccpath}/libgm2/libm2iso:${gm2src}/gm2-libs-iso";
-    set isoLpath "${gccpath}/libgm2/libm2iso/.libs";
+    lappend theIpath -I${gccpath}/libgm2/libm2log
+    lappend theIpath -I${gm2src}/gm2-libs
 
-    set logIpath "${gccpath}/libgm2/libm2log:${gm2src}/gm2-libs-pim";
-    set logLpath "${gccpath}/libgm2/libm2log/.libs";
+    lappend theLpath -L${gccpath}/libgm2/libm2log/.libs
 
-    set theIpath "-I${corIpath} -I${pimIpath} -I${logIpath} -I${isoIpath}";
-    set theLpath "-L${corLpath} -L${pimLpath} -L${logLpath} -L${isoLpath}";
+    lappend theIpath -I${gccpath}/libgm2/libm2iso
+    lappend theIpath -I${gm2src}/gm2-libs-iso
 
-    if { $path != "" } then {
-	append theIpath " -I"
-	append theIpath ${path}
+    lappend theLpath -L${gccpath}/libgm2/libm2iso/.libs
+
+    foreach p $paths {
+	lappend theIpath -I$p
     }
 
-    gm2_link_lib "m2cor m2pim m2iso"
-    gm2_init {*}${theIpath} -fpim {*}${theLpath} {*}${args};
+    gm2_link_lib "m2cor m2pim m2log m2iso"
+    append args " -fno-libs=- "
+    gm2_init {*}${theIpath} -fpim {*}${theLpath} {*}${args}
 }
 
 
@@ -537,27 +566,28 @@ proc gm2_init_cor { {path ""} args } {
 #
 #
 
-proc gm2_init_minx { dialect {path ""} args } {
-    global srcdir;
-    global gccpath;
-
-    set gm2src ${srcdir}/../m2;
+proc gm2_init_minx { dialect paths args } {
+    global srcdir
+    global gccpath
+    set gm2src ${srcdir}/../m2
 
     send_log "srcdir is $srcdir\n"
     send_log "gccpath is $gccpath\n"
     send_log "gm2src is $gm2src\n"
 
-    set minIpath "${gccpath}/libgm2/libm2min";
-    set minLpath "${gccpath}/libgm2/libm2min/.libs";
+    set theIpath -I${gccpath}/libgm2/libm2min
+    lappend theIpath -I${gm2src}/gm2-libs-min
 
-    set theIpath "-I${minIpath}";
-    set theLpath "-L${minLpath}";
+    set theLpath -L${gccpath}/libgm2/libm2min/.libs
 
-    if { $path != "" } then {
-	append theIpath " -I"
-	append theIpath ${path}
+    foreach p $paths {
+	lappend theIpath -I$p
     }
-    gm2_init {*}${theIpath} {*}${dialect} {*}${theLpath} {*}${args};
+
+    gm2_link_lib "m2min"
+    lappend args -fno-exceptions
+    lappend args -fno-libs=-
+    gm2_init {*}${theIpath} {*}${dialect} {*}${theLpath} {*}${args}
 }
 
 #
@@ -565,7 +595,6 @@ proc gm2_init_minx { dialect {path ""} args } {
 #                 and pim dialect.
 #
 
-proc gm2_init_min { {path ""} args } {
-    append args " -fno-exceptions"
-    gm2_init_minx -fpim {*}${path} {*}${args};
+proc gm2_init_min { paths args } {
+    gm2_init_minx -fpim $paths {*}${args}
 }
diff --git a/gcc/testsuite/lib/target-supports.exp b/gcc/testsuite/lib/target-supports.exp
index b906d40..227e300 100644
--- a/gcc/testsuite/lib/target-supports.exp
+++ b/gcc/testsuite/lib/target-supports.exp
@@ -869,8 +869,8 @@ proc check_effective_target_pcc_bitfield_type_matters { } {
 # Add to FLAGS all the target-specific flags needed to use thread-local storage.
 
 proc add_options_for_tls { flags } {
-    # On Solaris 9, __tls_get_addr/___tls_get_addr only lives in
-    # libthread, so always pass -pthread for native TLS. Same for AIX.
+    # On AIX, __tls_get_addr/___tls_get_addr only lives in
+    # libthread, so always pass -pthread for native TLS.
     # Need to duplicate native TLS check from
     # check_effective_target_tls_native to avoid recursion.
     if { ([istarget powerpc-ibm-aix*]) &&
@@ -5218,6 +5218,32 @@ proc check_effective_target_arm_cmse_clear_ok {} {
     } "-mcmse"];
 }
 
+# Return 1 if this is an ARM target supporting
+# -mbranch-protection=standard, 0 otherwise.
+
+proc check_effective_target_mbranch_protection_ok {} {
+
+    return [check_no_compiler_messages mbranch_protection_ok object {
+	int main (void) { return 0; }
+    } "-mbranch-protection=standard"]
+}
+
+# Return 1 if the target supports executing PACBTI instructions, 0
+# otherwise.
+
+proc check_effective_target_arm_pacbti_hw {} {
+    return [check_runtime arm_pacbti_hw_available {
+	__attribute__ ((naked)) int
+	main (void)
+	{
+	  asm ("pac r12, lr, sp");
+	  asm ("mov r0, #0");
+	  asm ("autg r12, lr, sp");
+	  asm ("bx lr");
+	}
+    } "-march=armv8.1-m.main+pacbti+fp -mbranch-protection=standard -mthumb -mfloat-abi=hard"]
+}
+
 # Return 1 if this compilation turns on string_ops_prefer_neon on.
 
 proc check_effective_target_arm_tune_string_ops_prefer_neon { } {
@@ -7099,7 +7125,8 @@ proc check_effective_target_vect_long_long { } {
 		 && [check_effective_target_s390_vx])
 	     || ([istarget powerpc*-*-*]
 		 && ![istarget powerpc-*-linux*paired*]
-		 && [check_effective_target_has_arch_pwr8]) }}]
+		 && [check_effective_target_has_arch_pwr8])
+	     || [istarget aarch64*-*-*] }}]
 }
 
 
diff --git a/gcc/tree-cfgcleanup.cc b/gcc/tree-cfgcleanup.cc
index ca0cb63..64ff16f 100644
--- a/gcc/tree-cfgcleanup.cc
+++ b/gcc/tree-cfgcleanup.cc
@@ -1106,9 +1106,11 @@ cleanup_tree_cfg_noloop (unsigned ssa_update_flags)
       timevar_push (TV_TREE_CLEANUP_CFG);
     }
 
-  /* Compute dominator info which we need for the iterative process below.  */
+  /* Compute dominator info which we need for the iterative process below.
+     Avoid computing the fast query DFS numbers since any block merging
+     done will invalidate them anyway.  */
   if (!dom_info_available_p (CDI_DOMINATORS))
-    calculate_dominance_info (CDI_DOMINATORS);
+    calculate_dominance_info (CDI_DOMINATORS, false);
   else
     checking_verify_dominators (CDI_DOMINATORS);
 
diff --git a/gcc/tree-core.h b/gcc/tree-core.h
index 8124a13..acd8dee 100644
--- a/gcc/tree-core.h
+++ b/gcc/tree-core.h
@@ -2284,17 +2284,20 @@ struct floatn_type_info {
 /* Matrix describing the structures contained in a given tree code.  */
 extern bool tree_contains_struct[MAX_TREE_CODES][64];
 
+/* Class of tree given its code.  */
+#if __cpp_inline_variables >= 201606L
 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
 #define END_OF_BASE_TREE_CODES tcc_exceptional,
 
-
-/* Class of tree given its code.  */
-constexpr enum tree_code_class tree_code_type[] = {
+constexpr inline enum tree_code_class tree_code_type[] = {
 #include "all-tree.def"
 };
 
 #undef DEFTREECODE
 #undef END_OF_BASE_TREE_CODES
+#else
+extern const enum tree_code_class tree_code_type[];
+#endif
 
 /* Each tree code class has an associated string representation.
    These must correspond to the tree_code_class entries.  */
@@ -2302,14 +2305,18 @@ extern const char *const tree_code_class_strings[];
 
 /* Number of argument-words in each kind of tree-node.  */
 
+#if __cpp_inline_variables >= 201606L
 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
 #define END_OF_BASE_TREE_CODES 0,
-constexpr unsigned char tree_code_length[] = {
+constexpr inline unsigned char tree_code_length[] = {
 #include "all-tree.def"
 };
 
 #undef DEFTREECODE
 #undef END_OF_BASE_TREE_CODES
+#else
+extern const unsigned char tree_code_length[];
+#endif
 
 /* Vector of all alias pairs for global symbols.  */
 extern GTY(()) vec<alias_pair, va_gc> *alias_pairs;
diff --git a/gcc/tree-inline.cc b/gcc/tree-inline.cc
index 6cb2981..7fd0831 100644
--- a/gcc/tree-inline.cc
+++ b/gcc/tree-inline.cc
@@ -183,7 +183,7 @@ remap_ssa_name (tree name, copy_body_data *id)
 	  return name;
 	}
 
-      return *n;
+      return unshare_expr (*n);
     }
 
   if (processing_debug_stmt)
diff --git a/gcc/tree-object-size.cc b/gcc/tree-object-size.cc
index 356591c..9a936a9 100644
--- a/gcc/tree-object-size.cc
+++ b/gcc/tree-object-size.cc
@@ -56,7 +56,7 @@ struct GTY(()) object_size
   tree wholesize;
 };
 
-static tree compute_object_offset (const_tree, const_tree);
+static tree compute_object_offset (tree, const_tree);
 static bool addr_object_size (struct object_size_info *,
 			      const_tree, int, tree *, tree *t = NULL);
 static tree alloc_object_size (const gcall *, int);
@@ -396,7 +396,7 @@ size_for_offset (tree sz, tree offset, tree wholesize = NULL_TREE)
    if unknown.  */
 
 static tree
-compute_object_offset (const_tree expr, const_tree var)
+compute_object_offset (tree expr, const_tree var)
 {
   enum tree_code code = PLUS_EXPR;
   tree base, off, t;
@@ -412,7 +412,8 @@ compute_object_offset (const_tree expr, const_tree var)
 	return base;
 
       t = TREE_OPERAND (expr, 1);
-      off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),
+      off = size_binop (PLUS_EXPR,
+			component_ref_field_offset (expr),
 			size_int (tree_to_uhwi (DECL_FIELD_BIT_OFFSET (t))
 				  / BITS_PER_UNIT));
       break;
diff --git a/gcc/tree-ssa-alias.cc b/gcc/tree-ssa-alias.cc
index b8f107d..7089e8b 100644
--- a/gcc/tree-ssa-alias.cc
+++ b/gcc/tree-ssa-alias.cc
@@ -3522,6 +3522,7 @@ stmt_kills_ref_p (gimple *stmt, ao_ref *ref)
 			       "ipa-modref: call to %s kills ",
 			       node->dump_name ());
 		      print_generic_expr (dump_file, ref->base);
+		      fprintf (dump_file, "\n");
 		    }
 		    ++alias_stats.modref_kill_yes;
 		    return true;
diff --git a/gcc/tree-ssa-forwprop.cc b/gcc/tree-ssa-forwprop.cc
index 0a7e956..0841a73 100644
--- a/gcc/tree-ssa-forwprop.cc
+++ b/gcc/tree-ssa-forwprop.cc
@@ -52,6 +52,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "internal-fn.h"
 #include "cgraph.h"
 #include "tree-ssa.h"
+#include "gimple-range.h"
 
 /* This pass propagates the RHS of assignment statements into use
    sites of the LHS of the assignment.  It's basically a specialized
@@ -1837,8 +1838,12 @@ defcodefor_name (tree name, enum tree_code *code, tree *arg1, tree *arg2)
    ((T) ((T2) X << Y)) | ((T) ((T2) X >> ((-Y) & (B - 1))))
    ((T) ((T2) X << (int) Y)) | ((T) ((T2) X >> (int) ((-Y) & (B - 1))))
 
-   transform these into:
+   transform these into (last 2 only if ranger can prove Y < B
+   or Y = N * B):
    X r<< Y
+   or
+   X r<< (& & (B - 1))
+   The latter for the forms with T2 wider than T if ranger can't prove Y < B.
 
    Or for:
    (X << (Y & (B - 1))) | (X >> ((-Y) & (B - 1)))
@@ -1866,6 +1871,9 @@ simplify_rotate (gimple_stmt_iterator *gsi)
   int i;
   bool swapped_p = false;
   gimple *g;
+  gimple *def_arg_stmt[2] = { NULL, NULL };
+  int wider_prec = 0;
+  bool add_masking = false;
 
   arg[0] = gimple_assign_rhs1 (stmt);
   arg[1] = gimple_assign_rhs2 (stmt);
@@ -1878,7 +1886,11 @@ simplify_rotate (gimple_stmt_iterator *gsi)
     return false;
 
   for (i = 0; i < 2; i++)
-    defcodefor_name (arg[i], &def_code[i], &def_arg1[i], &def_arg2[i]);
+    {
+      defcodefor_name (arg[i], &def_code[i], &def_arg1[i], &def_arg2[i]);
+      if (TREE_CODE (arg[i]) == SSA_NAME)
+	def_arg_stmt[i] = SSA_NAME_DEF_STMT (arg[i]);
+    }
 
   /* Look through narrowing (or same precision) conversions.  */
   if (CONVERT_EXPR_CODE_P (def_code[0])
@@ -1891,10 +1903,13 @@ simplify_rotate (gimple_stmt_iterator *gsi)
       && has_single_use (arg[0])
       && has_single_use (arg[1]))
     {
+      wider_prec = TYPE_PRECISION (TREE_TYPE (def_arg1[0]));
       for (i = 0; i < 2; i++)
 	{
 	  arg[i] = def_arg1[i];
 	  defcodefor_name (arg[i], &def_code[i], &def_arg1[i], &def_arg2[i]);
+	  if (TREE_CODE (arg[i]) == SSA_NAME)
+	    def_arg_stmt[i] = SSA_NAME_DEF_STMT (arg[i]);
 	}
     }
   else
@@ -1910,6 +1925,8 @@ simplify_rotate (gimple_stmt_iterator *gsi)
 	{
 	  arg[i] = def_arg1[i];
 	  defcodefor_name (arg[i], &def_code[i], &def_arg1[i], &def_arg2[i]);
+	  if (TREE_CODE (arg[i]) == SSA_NAME)
+	    def_arg_stmt[i] = SSA_NAME_DEF_STMT (arg[i]);
 	}
     }
 
@@ -1983,6 +2000,9 @@ simplify_rotate (gimple_stmt_iterator *gsi)
     {
       tree cdef_arg1[2], cdef_arg2[2], def_arg2_alt[2];
       enum tree_code cdef_code[2];
+      gimple *def_arg_alt_stmt[2] = { NULL, NULL };
+      int check_range = 0;
+      gimple *check_range_stmt = NULL;
       /* Look through conversion of the shift count argument.
 	 The C/C++ FE cast any shift count argument to integer_type_node.
 	 The only problem might be if the shift count type maximum value
@@ -1999,9 +2019,13 @@ simplify_rotate (gimple_stmt_iterator *gsi)
 	      && type_has_mode_precision_p (TREE_TYPE (cdef_arg1[i])))
 	    {
 	      def_arg2_alt[i] = cdef_arg1[i];
+	      if (TREE_CODE (def_arg2[i]) == SSA_NAME)
+		def_arg_alt_stmt[i] = SSA_NAME_DEF_STMT (def_arg2[i]);
 	      defcodefor_name (def_arg2_alt[i], &cdef_code[i],
 			       &cdef_arg1[i], &cdef_arg2[i]);
 	    }
+	  else
+	    def_arg_alt_stmt[i] = def_arg_stmt[i];
 	}
       for (i = 0; i < 2; i++)
 	/* Check for one shift count being Y and the other B - Y,
@@ -2018,18 +2042,28 @@ simplify_rotate (gimple_stmt_iterator *gsi)
 		|| cdef_arg2[i] == def_arg2_alt[1 - i])
 	      {
 		rotcnt = cdef_arg2[i];
+		check_range = -1;
+		if (cdef_arg2[i] == def_arg2[1 - i])
+		  check_range_stmt = def_arg_stmt[1 - i];
+		else
+		  check_range_stmt = def_arg_alt_stmt[1 - i];
 		break;
 	      }
 	    defcodefor_name (cdef_arg2[i], &code, &tem, NULL);
 	    if (CONVERT_EXPR_CODE_P (code)
 		&& INTEGRAL_TYPE_P (TREE_TYPE (tem))
 		&& TYPE_PRECISION (TREE_TYPE (tem))
-		 > floor_log2 (TYPE_PRECISION (rtype))
+		   > floor_log2 (TYPE_PRECISION (rtype))
 		&& type_has_mode_precision_p (TREE_TYPE (tem))
 		&& (tem == def_arg2[1 - i]
 		    || tem == def_arg2_alt[1 - i]))
 	      {
 		rotcnt = tem;
+		check_range = -1;
+		if (tem == def_arg2[1 - i])
+		  check_range_stmt = def_arg_stmt[1 - i];
+		else
+		  check_range_stmt = def_arg_alt_stmt[1 - i];
 		break;
 	      }
 	  }
@@ -2053,7 +2087,7 @@ simplify_rotate (gimple_stmt_iterator *gsi)
 	    if (CONVERT_EXPR_CODE_P (code)
 		&& INTEGRAL_TYPE_P (TREE_TYPE (tem))
 		&& TYPE_PRECISION (TREE_TYPE (tem))
-		 > floor_log2 (TYPE_PRECISION (rtype))
+		   > floor_log2 (TYPE_PRECISION (rtype))
 		&& type_has_mode_precision_p (TREE_TYPE (tem)))
 	      defcodefor_name (tem, &code, &tem, NULL);
 
@@ -2062,6 +2096,11 @@ simplify_rotate (gimple_stmt_iterator *gsi)
 		if (tem == def_arg2[1 - i] || tem == def_arg2_alt[1 - i])
 		  {
 		    rotcnt = tem;
+		    check_range = 1;
+		    if (tem == def_arg2[1 - i])
+		      check_range_stmt = def_arg_stmt[1 - i];
+		    else
+		      check_range_stmt = def_arg_alt_stmt[1 - i];
 		    break;
 		  }
 		tree tem2;
@@ -2076,6 +2115,11 @@ simplify_rotate (gimple_stmt_iterator *gsi)
 			|| tem2 == def_arg2_alt[1 - i])
 		      {
 			rotcnt = tem2;
+			check_range = 1;
+			if (tem2 == def_arg2[1 - i])
+			  check_range_stmt = def_arg_stmt[1 - i];
+			else
+			  check_range_stmt = def_arg_alt_stmt[1 - i];
 			break;
 		      }
 		  }
@@ -2111,6 +2155,50 @@ simplify_rotate (gimple_stmt_iterator *gsi)
 		  }
 	      }
 	  }
+      if (check_range && wider_prec > TYPE_PRECISION (rtype))
+	{
+	  if (TREE_CODE (rotcnt) != SSA_NAME)
+	    return false;
+	  int_range_max r;
+	  range_query *q = get_range_query (cfun);
+	  if (q == get_global_range_query ())
+	    q = enable_ranger (cfun);
+	  if (!q->range_of_expr (r, rotcnt, check_range_stmt))
+	    {
+	      if (check_range > 0)
+		return false;
+	      r.set_varying (TREE_TYPE (rotcnt));
+	    }
+	  int prec = TYPE_PRECISION (TREE_TYPE (rotcnt));
+	  signop sign = TYPE_SIGN (TREE_TYPE (rotcnt));
+	  wide_int min = wide_int::from (TYPE_PRECISION (rtype), prec, sign);
+	  wide_int max = wide_int::from (wider_prec - 1, prec, sign);
+	  if (check_range < 0)
+	    max = min;
+	  int_range<1> r2 (TREE_TYPE (rotcnt), min, max);
+	  r.intersect (r2);
+	  if (!r.undefined_p ())
+	    {
+	      if (check_range > 0)
+		{
+		  int_range_max r3;
+		  for (int i = TYPE_PRECISION (rtype) + 1; i < wider_prec;
+		       i += TYPE_PRECISION (rtype))
+		    {
+		      int j = i + TYPE_PRECISION (rtype) - 2;
+		      min = wide_int::from (i, prec, sign);
+		      max = wide_int::from (MIN (j, wider_prec - 1),
+					    prec, sign);
+		      int_range<1> r4 (TREE_TYPE (rotcnt), min, max);
+		      r3.union_ (r4);
+		    }
+		  r.intersect (r3);
+		  if (!r.undefined_p ())
+		    return false;
+		}
+	      add_masking = true;
+	    }
+	}
       if (rotcnt == NULL_TREE)
 	return false;
       swapped_p = i != 1;
@@ -2124,6 +2212,15 @@ simplify_rotate (gimple_stmt_iterator *gsi)
       gsi_insert_before (gsi, g, GSI_SAME_STMT);
       rotcnt = gimple_assign_lhs (g);
     }
+  if (add_masking)
+    {
+      g = gimple_build_assign (make_ssa_name (TREE_TYPE (rotcnt)),
+			       BIT_AND_EXPR, rotcnt,
+			       build_int_cst (TREE_TYPE (rotcnt),
+					      TYPE_PRECISION (rtype) - 1));
+      gsi_insert_before (gsi, g, GSI_SAME_STMT);
+      rotcnt = gimple_assign_lhs (g);
+    }
   lhs = gimple_assign_lhs (stmt);
   if (!useless_type_conversion_p (rtype, TREE_TYPE (def_arg1[0])))
     lhs = make_ssa_name (TREE_TYPE (def_arg1[0]));
@@ -3913,6 +4010,9 @@ pass_forwprop::execute (function *fun)
   BITMAP_FREE (to_purge);
   BITMAP_FREE (need_ab_cleanup);
 
+  if (get_range_query (cfun) != get_global_range_query ())
+    disable_ranger (cfun);
+
   if (cfg_changed)
     todoflags |= TODO_cleanup_cfg;
 
diff --git a/gcc/tree-ssa-loop-niter.cc b/gcc/tree-ssa-loop-niter.cc
index 65b9604..581bf5d 100644
--- a/gcc/tree-ssa-loop-niter.cc
+++ b/gcc/tree-ssa-loop-niter.cc
@@ -2252,16 +2252,16 @@ build_cltz_expr (tree src, bool leading, bool define_at_zero)
       call = build_call_expr_internal_loc (UNKNOWN_LOCATION, ifn,
 					   integer_type_node, 1, src);
       int val;
-      scalar_int_mode mode = SCALAR_INT_TYPE_MODE (utype);
       int optab_defined_at_zero
-	= leading ? CLZ_DEFINED_VALUE_AT_ZERO (mode, val)
-		  : CTZ_DEFINED_VALUE_AT_ZERO (mode, val);
+	= (leading
+	   ? CLZ_DEFINED_VALUE_AT_ZERO (SCALAR_INT_TYPE_MODE (utype), val)
+	   : CTZ_DEFINED_VALUE_AT_ZERO (SCALAR_INT_TYPE_MODE (utype), val));
       if (define_at_zero && !(optab_defined_at_zero == 2 && val == prec))
 	{
 	  tree is_zero = fold_build2 (NE_EXPR, boolean_type_node, src,
 				      build_zero_cst (TREE_TYPE (src)));
-	  call = fold_build3(COND_EXPR, integer_type_node, is_zero, call,
-			     build_int_cst (integer_type_node, prec));
+	  call = fold_build3 (COND_EXPR, integer_type_node, is_zero, call,
+			      build_int_cst (integer_type_node, prec));
 	}
     }
   else if (prec == 2 * lli_prec)
@@ -2275,22 +2275,22 @@ build_cltz_expr (tree src, bool leading, bool define_at_zero)
       /* We count the zeroes in src1, and add the number in src2 when src1
 	 is 0.  */
       if (!leading)
-	std::swap(src1, src2);
+	std::swap (src1, src2);
       tree call1 = build_call_expr (fn, 1, src1);
       tree call2 = build_call_expr (fn, 1, src2);
       if (define_at_zero)
 	{
 	  tree is_zero2 = fold_build2 (NE_EXPR, boolean_type_node, src2,
 				       build_zero_cst (TREE_TYPE (src2)));
-	  call2 = fold_build3(COND_EXPR, integer_type_node, is_zero2, call2,
-			      build_int_cst (integer_type_node, lli_prec));
+	  call2 = fold_build3 (COND_EXPR, integer_type_node, is_zero2, call2,
+			       build_int_cst (integer_type_node, lli_prec));
 	}
       tree is_zero1 = fold_build2 (NE_EXPR, boolean_type_node, src1,
 				   build_zero_cst (TREE_TYPE (src1)));
-      call = fold_build3(COND_EXPR, integer_type_node, is_zero1, call1,
-			 fold_build2 (PLUS_EXPR, integer_type_node, call2,
-				      build_int_cst (integer_type_node,
-						     lli_prec)));
+      call = fold_build3 (COND_EXPR, integer_type_node, is_zero1, call1,
+			  fold_build2 (PLUS_EXPR, integer_type_node, call2,
+				       build_int_cst (integer_type_node,
+						      lli_prec)));
     }
   else
     {
@@ -2302,14 +2302,13 @@ build_cltz_expr (tree src, bool leading, bool define_at_zero)
 	{
 	  tree is_zero = fold_build2 (NE_EXPR, boolean_type_node, src,
 				      build_zero_cst (TREE_TYPE (src)));
-	  call = fold_build3(COND_EXPR, integer_type_node, is_zero, call,
-			     build_int_cst (integer_type_node, prec));
+	  call = fold_build3 (COND_EXPR, integer_type_node, is_zero, call,
+			      build_int_cst (integer_type_node, prec));
 	}
 
       if (leading && prec < i_prec)
-	call = fold_build2(MINUS_EXPR, integer_type_node, call,
-			   build_int_cst (integer_type_node,
-					  i_prec - prec));
+	call = fold_build2 (MINUS_EXPR, integer_type_node, call,
+			    build_int_cst (integer_type_node, i_prec - prec));
     }
 
   return call;
diff --git a/gcc/tree-ssa-phiopt.cc b/gcc/tree-ssa-phiopt.cc
index c3a889d..a7ab6ce 100644
--- a/gcc/tree-ssa-phiopt.cc
+++ b/gcc/tree-ssa-phiopt.cc
@@ -1002,6 +1002,11 @@ match_simplify_replacement (basic_block cond_bb, basic_block middle_bb,
       if (!single_pred_p (middle_bb))
 	return false;
 
+      /* The middle bb cannot have phi nodes as we don't
+	 move those assignments yet. */
+      if (!gimple_seq_empty_p (phi_nodes (middle_bb)))
+	return false;
+
       stmt_to_move = last_and_only_stmt (middle_bb);
       if (!stmt_to_move)
 	return false;
diff --git a/gcc/tree-ssa-sccvn.cc b/gcc/tree-ssa-sccvn.cc
index 0dba3f3..028bedb 100644
--- a/gcc/tree-ssa-sccvn.cc
+++ b/gcc/tree-ssa-sccvn.cc
@@ -5826,7 +5826,7 @@ visit_phi (gimple *phi, bool *inserted, bool backedges_varying_p)
   poly_int64 soff, doff;
   unsigned n_executable = 0;
   edge_iterator ei;
-  edge e;
+  edge e, sameval_e = NULL;
 
   /* TODO: We could check for this in initialization, and replace this
      with a gcc_assert.  */
@@ -5867,7 +5867,10 @@ visit_phi (gimple *phi, bool *inserted, bool backedges_varying_p)
 		 && ssa_undefined_value_p (def, false))
 	  seen_undef = def;
 	else if (sameval == VN_TOP)
-	  sameval = def;
+	  {
+	    sameval = def;
+	    sameval_e = e;
+	  }
 	else if (!expressions_equal_p (def, sameval))
 	  {
 	    /* We know we're arriving only with invariant addresses here,
@@ -5905,7 +5908,8 @@ visit_phi (gimple *phi, bool *inserted, bool backedges_varying_p)
 		if (! val && vnresult && vnresult->predicated_values)
 		  {
 		    val = vn_nary_op_get_predicated_value (vnresult, e->src);
-		    if (val && integer_truep (val))
+		    if (val && integer_truep (val)
+			&& !(sameval_e && (sameval_e->flags & EDGE_DFS_BACK)))
 		      {
 			if (dump_file && (dump_flags & TDF_DETAILS))
 			  {
@@ -5923,7 +5927,8 @@ visit_phi (gimple *phi, bool *inserted, bool backedges_varying_p)
 		    if (EDGE_COUNT (bb->preds) == 2
 			&& (val = vn_nary_op_get_predicated_value
 				    (vnresult, EDGE_PRED (bb, 0)->src))
-			&& integer_truep (val))
+			&& integer_truep (val)
+			&& !(e->flags & EDGE_DFS_BACK))
 		      {
 			if (dump_file && (dump_flags & TDF_DETAILS))
 			  {
@@ -5943,6 +5948,8 @@ visit_phi (gimple *phi, bool *inserted, bool backedges_varying_p)
 	    sameval = NULL_TREE;
 	    break;
 	  }
+	else
+	  sameval_e = NULL;
       }
 
   /* If the value we want to use is flowing over the backedge and we
diff --git a/gcc/tree-vect-generic.cc b/gcc/tree-vect-generic.cc
index 2e2d756..166a248 100644
--- a/gcc/tree-vect-generic.cc
+++ b/gcc/tree-vect-generic.cc
@@ -2398,6 +2398,14 @@ expand_vector_operations (void)
 	  if (maybe_clean_eh_stmt (gsi_stmt (gsi))
 	      && gimple_purge_dead_eh_edges (bb))
 	    cfg_changed = true;
+	  /* If a .LOOP_DIST_ALIAS call prevailed loops got elided
+	     before vectorization got a chance to get at them.  Simply
+	     fold as if loop distribution wasn't performed.  */
+	  if (gimple_call_internal_p (gsi_stmt (gsi), IFN_LOOP_DIST_ALIAS))
+	    {
+	      fold_loop_internal_call (gsi_stmt (gsi), boolean_false_node);
+	      cfg_changed = true;
+	    }
 	}
     }
 
diff --git a/gcc/tree-vectorizer.cc b/gcc/tree-vectorizer.cc
index 875acbb..89cd0b8 100644
--- a/gcc/tree-vectorizer.cc
+++ b/gcc/tree-vectorizer.cc
@@ -1973,9 +1973,11 @@ vector_costs::compare_inside_loop_cost (const vector_costs *other) const
   HOST_WIDE_INT estimated_max_niter = likely_max_stmt_executions_int (loop);
   if (estimated_max_niter != -1)
     {
-      if (known_le (estimated_max_niter, this_vf))
+      if (estimated_poly_value (this_vf, POLY_VALUE_MIN)
+	  >= estimated_max_niter)
 	this_vf = estimated_max_niter;
-      if (known_le (estimated_max_niter, other_vf))
+      if (estimated_poly_value (other_vf, POLY_VALUE_MIN)
+	  >= estimated_max_niter)
 	other_vf = estimated_max_niter;
     }
 
diff --git a/gcc/tree.cc b/gcc/tree.cc
index 7473912..80c0967 100644
--- a/gcc/tree.cc
+++ b/gcc/tree.cc
@@ -74,7 +74,33 @@ along with GCC; see the file COPYING3.  If not see
 #include "asan.h"
 #include "ubsan.h"
 
+#if __cpp_inline_variables < 201606L
+/* Tree code classes.  */
 
+#define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
+#define END_OF_BASE_TREE_CODES tcc_exceptional,
+
+const enum tree_code_class tree_code_type[] = {
+#include "all-tree.def"
+};
+
+#undef DEFTREECODE
+#undef END_OF_BASE_TREE_CODES
+
+/* Table indexed by tree code giving number of expression
+   operands beyond the fixed part of the node structure.
+   Not used for types or decls.  */
+
+#define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
+#define END_OF_BASE_TREE_CODES 0,
+
+const unsigned char tree_code_length[] = {
+#include "all-tree.def"
+};
+
+#undef DEFTREECODE
+#undef END_OF_BASE_TREE_CODES
+#endif
 
 /* Names of tree components.
    Used for printing out the tree and error messages.  */
@@ -2669,6 +2695,35 @@ build_zero_cst (tree type)
     }
 }
 
+/* If floating-point type TYPE has an IEEE-style sign bit, return an
+   unsigned constant in which only the sign bit is set.  Return null
+   otherwise.  */
+
+tree
+sign_mask_for (tree type)
+{
+  /* Avoid having to choose between a real-only sign and a pair of signs.
+     This could be relaxed if the choice becomes obvious later.  */
+  if (TREE_CODE (type) == COMPLEX_TYPE)
+    return NULL_TREE;
+
+  auto eltmode = as_a<scalar_float_mode> (element_mode (type));
+  auto bits = REAL_MODE_FORMAT (eltmode)->ieee_bits;
+  if (!bits || !pow2p_hwi (bits))
+    return NULL_TREE;
+
+  tree inttype = unsigned_type_for (type);
+  if (!inttype)
+    return NULL_TREE;
+
+  auto mask = wi::set_bit_in_zero (bits - 1, bits);
+  if (TREE_CODE (inttype) == VECTOR_TYPE)
+    {
+      tree elt = wide_int_to_tree (TREE_TYPE (inttype), mask);
+      return build_vector_from_val (inttype, elt);
+    }
+  return wide_int_to_tree (inttype, mask);
+}
 
 /* Build a BINFO with LEN language slots.  */
 
@@ -10961,6 +11016,10 @@ signed_or_unsigned_type_for (int unsignedp, tree type)
 	return NULL_TREE;
       if (inner == inner2)
 	return type;
+      machine_mode new_mode;
+      if (VECTOR_MODE_P (TYPE_MODE (type))
+	  && related_int_vector_mode (TYPE_MODE (type)).exists (&new_mode))
+	return build_vector_type_for_mode (inner2, new_mode);
       return build_vector_type (inner2, TYPE_VECTOR_SUBPARTS (type));
     }
 
diff --git a/gcc/tree.h b/gcc/tree.h
index e730a2a..c656cd5 100644
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -4675,6 +4675,7 @@ extern tree build_one_cst (tree);
 extern tree build_minus_one_cst (tree);
 extern tree build_all_ones_cst (tree);
 extern tree build_zero_cst (tree);
+extern tree sign_mask_for (tree);
 extern tree build_string (unsigned, const char * = NULL);
 extern tree build_poly_int_cst (tree, const poly_wide_int_ref &);
 extern tree build_tree_list (tree, tree CXX_MEM_STAT_INFO);
diff --git a/gcc/value-relation.cc b/gcc/value-relation.cc
index b8fa765..5ca8a7e 100644
--- a/gcc/value-relation.cc
+++ b/gcc/value-relation.cc
@@ -32,7 +32,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "alloc-pool.h"
 #include "dominance.h"
 
-static const char *kind_string[VREL_LAST] =
+static const char *const kind_string[VREL_LAST] =
 { "varying", "undefined", "<", "<=", ">", ">=", "==", "!=", "pe8", "pe16",
   "pe32", "pe64" };
 
@@ -45,7 +45,7 @@ print_relation (FILE *f, relation_kind rel)
 }
 
 // This table is used to negate the operands.  op1 REL op2 -> !(op1 REL op2).
-relation_kind rr_negate_table[VREL_LAST] = {
+static const unsigned char rr_negate_table[VREL_LAST] = {
   VREL_VARYING, VREL_UNDEFINED, VREL_GE, VREL_GT, VREL_LE, VREL_LT, VREL_NE,
   VREL_EQ };
 
@@ -54,11 +54,11 @@ relation_kind rr_negate_table[VREL_LAST] = {
 relation_kind
 relation_negate (relation_kind r)
 {
-  return rr_negate_table [r];
+  return relation_kind (rr_negate_table [r]);
 }
 
 // This table is used to swap the operands.  op1 REL op2 -> op2 REL op1.
-relation_kind rr_swap_table[VREL_LAST] = {
+static const unsigned char rr_swap_table[VREL_LAST] = {
   VREL_VARYING, VREL_UNDEFINED, VREL_GT, VREL_GE, VREL_LT, VREL_LE, VREL_EQ,
   VREL_NE };
 
@@ -67,12 +67,12 @@ relation_kind rr_swap_table[VREL_LAST] = {
 relation_kind
 relation_swap (relation_kind r)
 {
-  return rr_swap_table [r];
+  return relation_kind (rr_swap_table [r]);
 }
 
 // This table is used to perform an intersection between 2 relations.
 
-relation_kind rr_intersect_table[VREL_LAST][VREL_LAST] = {
+static const unsigned char rr_intersect_table[VREL_LAST][VREL_LAST] = {
 // VREL_VARYING
   { VREL_VARYING, VREL_UNDEFINED, VREL_LT, VREL_LE, VREL_GT, VREL_GE, VREL_EQ,
     VREL_NE },
@@ -104,18 +104,18 @@ relation_kind rr_intersect_table[VREL_LAST][VREL_LAST] = {
 relation_kind
 relation_intersect (relation_kind r1, relation_kind r2)
 {
-  return rr_intersect_table[r1][r2];
+  return relation_kind (rr_intersect_table[r1][r2]);
 }
 
 
 // This table is used to perform a union between 2 relations.
 
-relation_kind rr_union_table[VREL_LAST][VREL_LAST] = {
+static const unsigned char rr_union_table[VREL_LAST][VREL_LAST] = {
 // VREL_VARYING
   { VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING,
     VREL_VARYING, VREL_VARYING, VREL_VARYING },
 // VREL_UNDEFINED
-  { VREL_VARYING, VREL_LT, VREL_LE, VREL_GT, VREL_GE, VREL_UNDEFINED,
+  { VREL_VARYING, VREL_UNDEFINED, VREL_LT, VREL_LE, VREL_GT, VREL_GE,
     VREL_EQ, VREL_NE },
 // VREL_LT
   { VREL_VARYING, VREL_LT, VREL_LT, VREL_LE, VREL_NE, VREL_VARYING, VREL_LE,
@@ -141,14 +141,14 @@ relation_kind rr_union_table[VREL_LAST][VREL_LAST] = {
 relation_kind
 relation_union (relation_kind r1, relation_kind r2)
 {
-  return rr_union_table[r1][r2];
+  return relation_kind (rr_union_table[r1][r2]);
 }
 
 
 // This table is used to determine transitivity between 2 relations.
 // (A relation0 B) and (B relation1 C) implies  (A result C)
 
-relation_kind rr_transitive_table[VREL_LAST][VREL_LAST] = {
+static const unsigned char rr_transitive_table[VREL_LAST][VREL_LAST] = {
 // VREL_VARYING
   { VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING,
     VREL_VARYING, VREL_VARYING, VREL_VARYING },
@@ -180,12 +180,12 @@ relation_kind rr_transitive_table[VREL_LAST][VREL_LAST] = {
 relation_kind
 relation_transitive (relation_kind r1, relation_kind r2)
 {
-  return rr_transitive_table[r1][r2];
+  return relation_kind (rr_transitive_table[r1][r2]);
 }
 
 // This vector maps a relation to the equivalent tree code.
 
-tree_code relation_to_code [VREL_LAST] = {
+static const tree_code relation_to_code [VREL_LAST] = {
   ERROR_MARK, ERROR_MARK, LT_EXPR, LE_EXPR, GT_EXPR, GE_EXPR, EQ_EXPR,
   NE_EXPR };
 
@@ -1718,3 +1718,28 @@ equiv_relation_iterator::get_name (relation_kind *rel)
     }
   return NULL_TREE;
 }
+
+#if CHECKING_P
+#include "selftest.h"
+
+namespace selftest
+{
+void
+relation_tests ()
+{
+  // rr_*_table tables use unsigned char rather than relation_kind.
+  ASSERT_LT (VREL_LAST, UCHAR_MAX);
+  // Verify commutativity of relation_intersect and relation_union.
+  for (relation_kind r1 = VREL_VARYING; r1 < VREL_PE8;
+       r1 = relation_kind (r1 + 1))
+    for (relation_kind r2 = VREL_VARYING; r2 < VREL_PE8;
+	 r2 = relation_kind (r2 + 1))
+      {
+	ASSERT_EQ (relation_intersect (r1, r2), relation_intersect (r2, r1));
+	ASSERT_EQ (relation_union (r1, r2), relation_union (r2, r1));
+      }
+}
+
+} // namespace selftest
+
+#endif // CHECKING_P